Recruiters spend a few seconds on a profile photo before they decide whether to keep scrolling. That is exactly why LinkedIn headshots and resume photos have become the newest testing ground for AI image generation, and why searches for “AI headshot generator” now clear 18,000 a month in the US alone. A PhotoPacksAI survey found that only 9% of job seekers have used AI tools for their headshot so far, compared with 19% who used AI for their resume and 20% for a cover letter. That gap will not last: the leading AI-headshot platforms alone processed more than 48 million sessions in 2025, according to HeadshotPhoto.io, and the broader AI-image-generator market grew to $555.1 million in 2026, per Grand View Research. This tutorial closes it: a full, code-backed workflow for generating a professional headshot with current AI image models, keeping your actual face intact instead of a generic AI approximation, and shipping a file that survives LinkedIn’s crop, a company directory, and a printed conference badge.
Dedicated apps like HeadshotPro, Aragon, or the newer Headshots.com will do this for you in an afternoon for roughly $29 to $79 as of September 2026, or, since Headshots.com’s one-photo AI headshot launch in July 2026, for as little as $15 for a single downloaded set. This guide is for the other reader: the one who wants control over the model, the prompt, the identity-preservation method, and the retouching pipeline, or who wants to build this into a product instead of buying one credit pack at a time. By the end you will have generated, cleaned up, and exported a headshot using an API-based model, tried a local ComfyUI route with FLUX.2, and built a small Python script that automates the whole batch.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Why Professional AI Headshots Are Suddenly Everywhere
Three things converged in 2026 to make AI headshot generator tools mainstream instead of a novelty. First, photorealism crossed a threshold: models like Nano Banana 2, FLUX.2, and Seedream 5.0 now render skin texture, pore detail, and natural catchlights well enough that a trained eye needs several seconds, not a glance, to spot a fake. Second, identity-preservation techniques matured. LoRA training, InstantID, PuLID, and IP-Adapter FaceID all reached the point where a stranger’s face can be locked into a generation without months of research-lab tooling. Third, the price collapsed. A studio headshot session with a photographer typically runs $150 to $500 per person once retouching is included, while an AI headshot generator produces dozens of usable variations for $29 to $75, or a few cents per image if you run the generation yourself through an API or locally through ComfyUI.
That price gap is precisely why remote teams, job seekers rebuilding a LinkedIn profile, startups outfitting an “about” page, and recruiters standardizing headshots across a hundred-person sales team have all adopted some version of this workflow in the last year. The catch nobody advertises: dedicated AI headshot generator apps make the easy 80% of the job automatic and leave you stuck on the hard 20%, namely the uncanny-valley artifacts around hands, ears, teeth, and eyes that give away a synthetic image. This tutorial spends most of its time on exactly that 20%.
Prerequisites: Tools, Models, and Versions You Will Need
You do not need every tool below. Pick the API route if you want the fastest path with no local GPU. Pick the local route if you want free, unlimited generations and full control over the identity-preservation method. This tutorial covers both, and the versions below were current as of September 25, 2026.
- Python 3.11 or newer for the automation scripts in this guide
- An API key for at least one cloud image model: Nano Banana 2 (Google), FLUX.2 (Black Forest Labs), Qwen-Image 3.0 (Alibaba), Seedream 5.0 (ByteDance), or Grok Imagine Image 2.0 (xAI)
- ComfyUI (latest tagged release, v0.37.x as of September 2026) if you want to run generation locally, requires an NVIDIA GPU with 12GB+ VRAM for FLUX.2 Klein at full precision, or 8GB with GGUF quantization
- rembg or a background-removal API for isolating the subject from the generated background
- An identity-preservation method: a personal LoRA (trained on 15 to 30 of your own photos), or a zero-shot adapter such as InstantID, PuLID, or IP-Adapter FaceID
- 15 to 30 source photos of the subject’s face, taken in good lighting, from multiple angles
- An image editor or inpainting tool for fixing localized artifacts (Photoshop, GIMP, or an inpainting node inside ComfyUI)
- Basic command-line comfort, since several steps involve running Python scripts
If you would rather skip the technical setup entirely, a dedicated AI headshot generator app is the faster path, and this guide explains where those tools fit and where they fall short later on. For everyone else, here are the 11 steps.
Step 1: Choose a Generation Strategy
Every AI headshot workflow reduces to one of two strategies, and picking the wrong one wastes hours. Prompt-only generation means describing a person and letting the model invent a face, useful for exploring clothing, lighting, and composition, but useless if the output needs to resemble a specific real person. Identity-preserving generation means anchoring the output to a real face, either through a trained LoRA, a zero-shot face adapter, or a reference-image feature built into the model itself.
For a professional headshot, you almost always want identity-preserving generation. The exception is generating a placeholder avatar, a stock-style “team member” photo for a demo site, or design mockups where no real likeness is required. This tutorial focuses on the identity-preserving path since that is what “professional headshot” implies: a photo that looks like you, not a photo that looks like a person.
Step 2: Build a Source Photo Set That Preserves Your Identity
The single biggest driver of a convincing result is not the prompt, the model, or even the identity-preservation method. It is the quality of your source photo set. Every generation technique, from LoRA training to IP-Adapter FaceID, works by extracting facial features from reference images, so garbage references produce a face that is only vaguely you.
Assemble 15 to 30 photos with these characteristics:
- Clear, unobstructed views of the full face, no sunglasses, no heavy shadows across the eyes
- A mix of angles: straight-on, three-quarter left, three-quarter right, and a slight profile
- Neutral to relaxed expressions, avoid extreme smiles or exaggerated poses in most of the set
- Consistent identity features across the set: same hairstyle, same facial hair, same glasses (or none) in most shots
- Even, diffuse lighting, natural window light works better than harsh flash or backlighting
- At least a few images at native resolution above 1024 pixels on the short edge
- No heavy filters, no beauty-mode smoothing, no motion blur
If you are training a LoRA specifically, crop each image to roughly a square or portrait aspect ratio centered on the head and shoulders, but keep some variation in framing so the model does not learn your exact crop as part of your identity.
Step 3: Compare the Leading AI Models for Photorealistic Headshots
Not every image model handles faces the same way. Some prioritize stylistic flexibility over anatomical accuracy, some charge by megapixel instead of per image, and only a handful ship an open-weight variant you can run locally with a personal LoRA attached. The table below reflects publicly listed pricing as of September 2026, though the field kept moving even after that snapshot: OpenAI released GPT-Image-2.5 Sunburst and Flare in October 2026 with its own published API pricing, and it is worth benchmarking against the models below once you have a working pipeline. Always confirm current rates before building a production pipeline, since AI image API pricing has moved multiple times this year.
| Model | Maker | Access | Approx. Price | Headshot Strengths |
|---|---|---|---|---|
| Nano Banana 2 | Cloud API | ~$0.067 / image | Consistent skin tone, strong lighting realism | |
| FLUX.2 Klein (4B) | Black Forest Labs | Open weight, local or API | ~$0.014 / megapixel | Runs on consumer GPUs, pairs well with LoRA |
| Qwen-Image 3.0 | Alibaba | Cloud API | ~$0.03 / image (1K) | Sharp detail, strong at accessories and text on badges |
| Seedream 5.0 Lite | ByteDance | Cloud API | ~$0.035 / image (2048px) | High native resolution output |
| Grok Imagine Image 2.0 | xAI | Cloud API | ~$0.04–0.06 / image | Fast iteration for prompt testing |
| Midjourney v8.2 | Midjourney Inc. | Subscription, Discord/web | $10–$60 / month | Strong stylistic control, weaker literal likeness without character reference |
For a first attempt, FLUX.2 Klein is the most practical starting point if you have any GPU with 12GB or more of VRAM, since it is Apache 2.0 licensed and pairs directly with an identity LoRA without per-image cost. Nano Banana 2 and Seedream 5.0 Lite are the strongest cloud options if you do not want to manage local infrastructure. If your team already runs a multi-model AI image pipeline, route headshot jobs to whichever model currently scores best on your internal quality benchmark rather than hard-coding one provider.
Dedicated AI Headshot Generator Apps
If building this pipeline yourself is more effort than the headshot is worth, dedicated apps package the same underlying techniques behind a simple upload-and-wait flow. HeadshotPro alone reports having generated 17.9 million headshots for more than 196,000 customers as of September 2026, and rival HeadshotPhoto.io says it had produced over 1.4 million headshots for more than 50,000 professionals by December 2025, a sense of how mainstream the category has become. As of September 2026, reported package pricing across the category runs roughly $29 to $79, with HeadshotPro’s tiers near $29, $39, and $59, Aragon’s near $35, $45, and $75, Secta’s near $29 to $49, and newcomer Headshots.com, which launched a one-photo AI headshot option in July 2026, pricing a single downloaded set at just $15. Package contents (image count, style count, delivery time) vary between sources and change with promotions, so confirm the current terms at checkout rather than relying on any single published number, including the ones here.
Privacy and Data Handling: What Happens to Your Photos
Before uploading a folder of your face to any service, it is worth pausing on where those photos actually go. A cloud API call sends your source images to a third-party server, and most providers reserve some right to retain uploaded content for abuse monitoring or model improvement unless you are on a paid tier with an explicit no-training clause. Read the data retention section of the terms of service for whichever model you pick in Step 3, not just the pricing page, since retention policies differ far more between providers than image quality does.
This matters more for a company-wide headshot refresh than for a single personal photo, since uploading a hundred employees’ faces to a third-party service creates a much larger dataset with a much larger blast radius if it is mishandled. Three practical guardrails help: first, prefer providers that explicitly state uploaded images are not used for model training by default. Second, if the headshots are for an organization, get a written data processing agreement rather than relying on a general terms-of-service page. Third, if privacy is the deciding factor, the local ComfyUI and FLUX.2 route from Step 4 never sends a single photo off your own machine, which is the only way to guarantee zero third-party retention.
Dedicated AI headshot generator apps sit in the middle of this spectrum. Most delete source uploads after a fixed retention window, commonly 30 to 90 days, but policies vary enough between HeadshotPro, Aragon, and Secta that it is worth checking each provider’s current privacy page rather than assuming they all handle retention the same way.
How This Compares to Traditional Photo Retouching Workflows
Professional photo retouchers have used layered, non-destructive editing for decades, and the AI headshot workflow in this tutorial borrows more from that discipline than it might first appear. A retoucher working in Photoshop separates frequency layers to fix skin texture without flattening it, dodges and burns to shape light rather than repainting it, and never touches the whole image at once when a localized fix will do. The targeted inpainting approach in Step 8 is the AI-generation equivalent of that same discipline: fix the eye, not the face, fix the ear, not the head.
The practical difference is speed and cost, not the underlying logic. A retoucher might spend 20 to 40 minutes per final image getting skin, eyes, and color grading exactly right, and charge accordingly. This workflow compresses that into a few inpainting passes and an upscale step, at the cost of slightly less control over fine, subjective details like exact skin tone warmth. For most professional headshot use cases, that tradeoff is worth it. For a magazine cover or a print campaign, a human retoucher is still the better tool for the final 5% of polish.
Step 4: Set Up Your Generation Environment
The fastest path is a cloud API call. Here is a minimal Python client that sends a reference image and a prompt to an image generation API and saves the result. Swap the endpoint and payload shape for whichever provider you chose in Step 3. The structure below matches the common pattern of a base64-encoded reference image plus a text prompt.
import base64
import requests
API_KEY = "YOUR_API_KEY"
ENDPOINT = "https://api.example-image-model.com/v1/generate"
def encode_image(path):
with open(path, "rb") as f:
return base64.b64encode(f.read()).decode("utf-8")
def generate_headshot(reference_path, prompt, negative_prompt, out_path):
payload = {
"prompt": prompt,
"negative_prompt": negative_prompt,
"reference_image": encode_image(reference_path),
"reference_strength": 0.65,
"width": 1024,
"height": 1280,
"num_images": 4,
}
headers = {"Authorization": f"Bearer {API_KEY}"}
response = requests.post(ENDPOINT, json=payload, headers=headers, timeout=60)
response.raise_for_status()
data = response.json()
for i, item in enumerate(data["images"]):
img_bytes = base64.b64decode(item["b64"])
with open(f"{out_path}_{i}.png", "wb") as f:
f.write(img_bytes)
print(f"Saved {len(data['images'])} candidate headshots to {out_path}_*.png")
if __name__ == "__main__":
generate_headshot(
reference_path="source_photos/front_01.jpg",
prompt="PROMPT_FROM_STEP_6",
negative_prompt="NEGATIVE_PROMPT_FROM_STEP_6",
out_path="output/headshot_v1",
)If you are going the local route instead, install ComfyUI (the latest tagged release was v0.37.0, published September 21, 2026), then use ComfyUI Manager to pull in the FLUX.2 node pack and an identity-adapter custom node bundle. The full ComfyUI setup walkthrough on this site covers installation, model placement, and the API server in detail if you have not run ComfyUI before.
Step 5: Preserve Identity With LoRA and Face Adapters
This is the step that separates a headshot that looks like you from one that looks like a stranger who is vaguely similar. You have two realistic options.
Option A: Train a Personal LoRA
A LoRA (low-rank adaptation) is a small trainable adapter layered on top of a base image model, and it currently holds the largest share of the parameter-efficient fine-tuning tooling market, an estimated 38.5% as of late 2025 according to market researcher Dataintelo. Training one on your own face set from Step 2 typically costs about $2 in cloud GPU credits or runs free on a local GPU with 12GB or more of VRAM, and takes 20 to 40 minutes. The full walkthrough for this exact process is covered in this site’s dedicated LoRA training tutorial. The short version below shows a typical training configuration for a face LoRA on top of FLUX.2.
# train_config.yaml — face LoRA on FLUX.2 Klein
base_model: "flux2-klein-4b"
dataset_dir: "./source_photos"
resolution: 1024
rank: 16
learning_rate: 0.0001
train_steps: 1500
caption_prefix: "a photo of sks_person,"
save_every_n_steps: 300
output_dir: "./lora_output/sks_person_v1"A unique token such as sks_person prevents the model from confusing your identity with an existing concept it already knows. Start generations at a LoRA strength of 0.6 to 0.7. Pushing strength toward 1.0 usually produces a waxy, overfit face rather than a more accurate one.
Option B: Use a Zero-Shot Identity Adapter
If training a LoRA is more setup than you want, InstantID, PuLID, and IP-Adapter FaceID extract a face embedding from one or two reference photos and inject it into the generation process without any training step. This is faster to set up and works well when you need many different outfits, backgrounds, or poses quickly, though it generally preserves likeness slightly less precisely than a well-trained personal LoRA. A practical middle path many people use: generate the initial batch with a zero-shot adapter for speed, then fall back to a LoRA only if the identity match is not close enough.
Step 6: Engineer a Prompt That Avoids the Uncanny Valley
Once identity preservation is in place, the prompt controls everything else: lighting, wardrobe, background, and camera feel. Add constraints rather than piling on adjectives, since an over-decorated prompt tends to produce a busier, less believable image. Here is a template that performs consistently well across FLUX.2, Nano Banana 2, and Seedream 5.0:
Photorealistic professional head-and-shoulders portrait of sks_person,
accurate facial identity, natural facial proportions, relaxed neutral expression,
direct eye contact, subtle closed-mouth smile, business-casual navy blazer,
clean light-gray studio background, soft key light from camera left,
gentle fill light, subtle hair rim light, realistic skin texture with visible pores,
85mm portrait lens, shallow but natural depth of field, sharp eyes,
balanced exposure, editorial corporate photography,
vertical 4:5 composition, centered framing, head and upper shoulders visiblePair it with a negative prompt to steer the model away from the most common headshot failure modes. Not every model supports negative prompts natively, so treat this as an optional control rather than a universal switch:
no altered facial structure, no beauty-filter skin, no plastic skin,
no extra teeth, no asymmetrical eyes, no crossed eyes, no distorted ears,
no duplicate features, no harsh sharpening, no text, no watermark,
no exaggerated smile, no visible hands, no warped collarUseful lens and lighting keywords for a headshot specifically: an 85mm to 105mm equivalent focal length reads as a natural portrait lens, an aperture around f/2.8 to f/5.6 keeps enough of the face in focus without excessive background blur, and describing a “large softbox key light with gentle fill” produces more even, professional-looking skin than generic “cinematic lighting” prompts, which tend to introduce dramatic shadows unsuitable for a corporate photo.
Step 7: Generate and Batch Your First Headshots
Generate in small batches of four to eight images per configuration rather than committing to one image at a time. Keep the identity reference and LoRA strength fixed, and vary only one variable per batch, background, wardrobe color, or expression, so you can tell what actually changed the result. The script below extends the Step 4 client into a batch runner that sweeps a few prompt variations automatically.
import itertools
from pathlib import Path
BASE_PROMPT = (
"Photorealistic professional head-and-shoulders portrait of sks_person, "
"accurate facial identity, relaxed neutral expression, direct eye contact, "
"85mm portrait lens, editorial corporate photography, vertical 4:5 composition"
)
NEGATIVE_PROMPT = (
"no altered facial structure, no plastic skin, no extra teeth, "
"no distorted ears, no visible hands, no text, no watermark"
)
BACKGROUNDS = ["clean light-gray studio background", "softly blurred modern office background"]
WARDROBE = ["business-casual navy blazer", "charcoal suit jacket, white collared shirt"]
def run_sweep(reference_path):
Path("output").mkdir(exist_ok=True)
for i, (bg, wardrobe) in enumerate(itertools.product(BACKGROUNDS, WARDROBE)):
prompt = f"{BASE_PROMPT}, {wardrobe}, {bg}"
generate_headshot(
reference_path=reference_path,
prompt=prompt,
negative_prompt=NEGATIVE_PROMPT,
out_path=f"output/sweep_{i}",
)
if __name__ == "__main__":
run_sweep("source_photos/front_01.jpg")This produces 16 candidates from two backgrounds times two wardrobe options times four images per call, enough variety to find one strong result without burning through a full day of API credits.
Step 8: Inspect, Cull, and Fix Artifacts With Targeted Inpainting
Open every candidate at full resolution before doing anything else to the background or file format. Reject any image with a changed jawline, nose shape, or eye spacing, incorrect facial hair or glasses versus your reference, unnatural pupils or mismatched eye direction, repeated or smeared skin texture, or teeth that look fused together. Identity correction is far easier at this stage than after you have already composited a new background or run an upscaler.
For the images worth saving but not perfect, use targeted inpainting rather than regenerating the whole frame. Mask only the problem area, keep the mask as small as possible, and regenerate with the same identity reference active so the fix does not drift away from the rest of the face. The most common regions that need a touch-up pass are eyes and eyebrows, teeth, ears and earrings, the collar and lapel line, and flyaway hair at the hairline. Running several broad inpainting passes across a large area of the face gradually changes the person’s identity, so keep each pass small and specific.
Step 9: Remove and Replace the Background
Once you have a clean face, isolate the subject with a segmentation tool. The open-source rembg library handles this well for headshots since the subject-to-background contrast is usually high. Install it with pip install rembg, then run:
from rembg import remove
from PIL import Image
input_path = "output/sweep_0_2.png"
output_path = "output/sweep_0_2_cutout.png"
with open(input_path, "rb") as f:
input_bytes = f.read()
output_bytes = remove(input_bytes)
with open(output_path, "wb") as f:
f.write(output_bytes)
print("Cutout saved:", output_path)Inspect the mask edges closely around hair strands, ear contours, and glasses frames, since a hard, perfectly clean cutout usually looks more artificial than one with a slight, natural edge. Add a subtle defringe pass and a small amount of contact shadow if compositing onto a new background, since a subject with zero shadow reads as obviously pasted.
Step 10: Upscale Without Losing Likeness
Upscaling should restore detail, not invent a new face. Face-restoration upscalers in particular tend to “beautify” a face toward an averaged, generic appearance, which works against everything you did in Steps 5 through 8 to keep the likeness accurate. Use a moderate upscale factor, generally 2x rather than 4x, and compare the result side by side with the pre-upscale version before accepting it. This site’s dedicated AI image upscaling guide covers the current tool options in depth. The short version for a headshot specifically is to disable or lower any “face enhancement” toggle and inspect eyelashes, teeth, and skin texture after upscaling rather than assuming it improved the image.
Step 11: Export, Label, and Deploy Across Platforms
Different platforms crop differently, so export more than one aspect ratio from your final image rather than forcing one crop everywhere. LinkedIn displays a square crop but stores more of the frame, so a 4:5 vertical original gives it room to work with. A resume header typically wants a tighter square crop. A company directory page often wants 3:4 to show more shoulder and torso area for context.
| Destination | Recommended Aspect Ratio | Minimum Resolution |
|---|---|---|
| LinkedIn profile photo | 1:1 (crop from 4:5 original) | 400 x 400 px |
| Resume header | 1:1 | 300 x 300 px |
| Company “About” page | 3:4 | 800 x 1067 px |
| Conference badge / print | 4:5 | 1500 x 1875 px (print resolution) |
If your organization has a policy on disclosing AI-generated imagery, or you simply want to be transparent, consider embedding a C2PA content credential in the final export so anyone who inspects the file metadata can see it was AI-assisted. This site’s C2PA labeling guide covers how to attach that credential, and the C2PA specification itself is publicly documented if you want to implement it directly.
Common Pitfalls When Generating AI Headshots
- Using too few source photos. Five or six photos rarely give a LoRA or identity adapter enough variation to generalize. Fifteen to 30 is a safer floor.
- Pushing LoRA or adapter strength too high. Maximum strength does not mean maximum accuracy. It usually produces a stiff, overfit, waxy face instead.
- Skipping the cull step and upscaling everything. Upscaling a flawed generation just produces a larger, sharper flaw. Cull first, upscale last.
- Relying on one giant inpainting pass to fix multiple problems at once. Broad regeneration drifts identity further from the reference with every pass.
- Ignoring aspect ratio until the last step. Generating at a square ratio and cropping a 4:5-appropriate composition afterward loses headroom and framing control.
- Trusting a single reported price for dedicated headshot apps. Package sizes and pricing for tools like Aragon, HeadshotPro, and Secta shift with promotions, so confirm current terms before paying.
- Treating negative prompts as universally supported. Not every model honors them the same way, so verify behavior on your chosen model rather than assuming.
Troubleshooting Guide: Common Problems and Fixes
| Problem | Likely Cause | Fix |
|---|---|---|
| Face looks like a different person | Weak identity reference or LoRA strength too low | Increase reference strength gradually, or add more varied source photos |
| Face looks waxy or overfit | LoRA or adapter strength too high | Lower strength to 0.5–0.7 range and regenerate |
| Visible extra fingers or malformed hands | Hands are poorly constrained by most image models | Crop hands out of frame or hide them behind the torso in the prompt and composition |
| Distorted or asymmetrical ears | Side-angle references confuse the model, or hair obscures the ear | Use a clear front or three-quarter reference and inpaint each ear separately |
| Fused or malformed teeth | Open-mouth smile produces unstable geometry | Prompt for a closed-mouth smile, or mask and inpaint the mouth only |
| Mismatched or asymmetrical eyes | Weak identity control combined with heavy stylization | Mask each eye separately and regenerate at lower prompt strength |
| Background looks pasted after cutout | Segmentation mask is too hard-edged, no shadow added | Refine the mask, add a subtle edge defringe and contact shadow |
| Upscaler changes the face rather than sharpening it | Face-restoration mode is enabled and beautifying features | Disable face enhancement, use a general-purpose upscaler at 2x |
| Out-of-memory error running FLUX.2 locally | Insufficient VRAM for full-precision model | Switch to a GGUF-quantized checkpoint or the smaller Klein variant |
| Model ignores the negative prompt entirely | The chosen model does not support negative prompt conditioning | Move unwanted terms into the positive prompt as explicit constraints, or switch models |
Advanced Tips: Automating Headshot Generation at Scale
Once the single-person workflow is reliable, standardizing headshots across an entire team is mostly a batching problem. The script below loops over a folder of employee reference photos, trains or loads a per-person LoRA reference tag, and runs the same prompt template from Step 6 for everyone, keeping the studio background and lighting identical across the whole company directory.
import os
from pathlib import Path
TEAM_DIR = Path("team_photos")
OUTPUT_DIR = Path("team_headshots")
OUTPUT_DIR.mkdir(exist_ok=True)
STANDARD_PROMPT = (
"Photorealistic professional head-and-shoulders portrait of {token}, "
"accurate facial identity, relaxed neutral expression, direct eye contact, "
"business-casual attire, clean light-gray studio background, "
"85mm portrait lens, editorial corporate photography, vertical 4:5 composition"
)
NEGATIVE_PROMPT = (
"no altered facial structure, no plastic skin, no extra teeth, "
"no distorted ears, no visible hands, no text, no watermark"
)
def process_team():
for person_dir in TEAM_DIR.iterdir():
if not person_dir.is_dir():
continue
token = f"sks_{person_dir.name}"
reference_path = next(person_dir.glob("*.jpg"), None)
if reference_path is None:
print(f"No reference photo for {person_dir.name}, skipping")
continue
prompt = STANDARD_PROMPT.format(token=token)
out_path = OUTPUT_DIR / person_dir.name
generate_headshot(
reference_path=str(reference_path),
prompt=prompt,
negative_prompt=NEGATIVE_PROMPT,
out_path=str(out_path),
)
print(f"Generated headshots for {person_dir.name}")
if __name__ == "__main__":
process_team()Two things matter for team-wide consistency that do not matter for a single headshot: locking the studio background and lighting description word-for-word across every person, and reviewing outputs in a single contact sheet rather than one at a time, since inconsistent color grading between people is far easier to spot side by side than in isolation. If you already run a multi-model image generation pipeline with fallback logic, route headshot batches through it so a rate limit or outage on one provider does not block the whole team’s photos.
For consistency checks across a larger set of generated headshots, treat it the same way you would testing consistency across multiple AI character generations: generate the same person across several prompt variations, then compare which images a blind reviewer correctly matches to the reference photo. If your identity-preservation setup is solid, match rates should be high even across different backgrounds and wardrobe.
Cost and Time: AI Headshots vs Professional Photography
The economics are the whole reason this workflow exists, and the market has grown to match: AI portrait and headshot revenue reached roughly $420 million in 2025, according to HeadshotPhoto.io, and the broader AI-image-generator market climbed to $555.1 million in 2026 per Grand View Research. A traditional headshot session with a photographer, studio rental, and basic retouching typically runs $150 to $500 per person and requires scheduling a shoot, which for a distributed team means either flying people in or paying for photographers in every city. The AI route trades that scheduling overhead for setup time and iteration.
| Method | Typical Cost | Turnaround | Best For |
|---|---|---|---|
| Professional photographer | $150–$500 per person | Days to weeks (scheduling) | Executive photos, small teams, high-stakes branding |
| Dedicated AI headshot app | $29–$75 one-time | 10–30 minutes | Individuals, quick turnaround, no technical setup |
| Cloud API + this workflow | $1–$5 in API credits per person | 30–60 minutes hands-on | Teams, custom branding, developers who want control |
| Local ComfyUI + FLUX.2 Klein | Electricity only, after setup | 1–2 hours setup, then minutes per person | High-volume batches, privacy-sensitive photos, no per-image cost |
The local ComfyUI route has the steepest learning curve but the lowest marginal cost, which makes sense for a 50-person company directory refresh but is overkill for a single LinkedIn photo. Match the method to the batch size, not the other way around.
Frequently Asked Questions
Which AI model produces the most realistic headshots in 2026?
There is no single winner across every case. Nano Banana 2 and Seedream 5.0 Lite currently produce strong skin realism and lighting out of a cloud API, FLUX.2 Klein remains the strongest open-weight option since it can be paired directly with a personal LoRA for local, unlimited generation, and OpenAI’s GPT-Image-2.5 Sunburst and Flare, released in October 2026 with its own API pricing, is a new contender worth testing against all three. Run a small comparison batch with your own reference photos before committing to one provider, since face rendering quality varies by individual features more than benchmark scores suggest.
Do I need to train a LoRA, or can I skip straight to a zero-shot adapter?
Start with a zero-shot adapter like InstantID or IP-Adapter FaceID since setup takes minutes and requires no training run. Move to a personal LoRA only if the identity match from the zero-shot adapter is not close enough, since LoRA training generally preserves likeness a bit more precisely at the cost of 20 to 40 minutes of setup time.
How many source photos do I actually need?
Fifteen to thirty is a reliable range for both LoRA training and zero-shot identity adapters. Fewer than ten photos usually leaves the model with too little variation to generalize your face across different angles, expressions, and lighting.
Is it worth building this pipeline myself instead of paying for a dedicated AI headshot generator app?
For a single headshot, a dedicated app like HeadshotPro or Aragon is almost always faster and cheaper in terms of your time, at roughly $29 to $75 one time. Building this pipeline yourself pays off when you need to generate headshots for an entire team repeatedly, need a specific brand-consistent background and lighting style, or want to avoid uploading employee photos to a third-party service.
Why do AI headshots so often get hands, ears, and teeth wrong?
These are high-detail, high-variability structures that most training data represents inconsistently, hands especially, since they appear in countless poses and are frequently partially obscured in photos. The practical fix is not a better prompt. It is composition that keeps hands out of frame and targeted inpainting for ears and teeth after the main generation.
Can I run this entire workflow without any cloud API costs?
Yes, using FLUX.2 Klein through ComfyUI running locally with an identity LoRA or adapter. You will need a GPU with at least 8GB of VRAM using a GGUF-quantized checkpoint, or 12GB or more for full precision. After the initial setup, generation cost is limited to your electricity bill.
Should I disclose that a headshot was AI-generated?
Policies vary by organization and platform, and this is ultimately a judgment call rather than a universal rule. If transparency matters for your use case, embedding a C2PA content credential in the exported file is a standardized way to make the AI-assisted origin verifiable in the file metadata without adding a visible watermark to the image itself.
What is the biggest mistake people make with AI headshots?
Pushing identity-preservation strength as high as it goes in an attempt to maximize likeness. In practice this produces the opposite: a stiff, overfit, slightly waxy face. A moderate strength setting combined with a good source photo set consistently outperforms maximum strength with a mediocre source set.
Can I use this workflow to generate headshots for other people without their consent?
You should only train a LoRA or use an identity adapter on photos of someone who has given permission, both because it is the right thing to do and because most image model providers explicitly prohibit generating likenesses of real people without consent in their terms of service. For a company-wide headshot project, get that consent in writing as part of rolling out the initiative, not as an afterthought.
How long does the entire process take from source photos to a finished headshot?
For a single person using the cloud API route, expect 30 to 60 minutes hands-on: roughly 10 minutes to select and prep source photos, 10 to 15 minutes to generate and review a batch, 10 to 20 minutes for inpainting touch-ups, and a few minutes for upscaling and export. The local ComfyUI route adds 1 to 2 hours of one-time setup, but after that, each additional person takes only a few minutes since the environment and identity-preservation pipeline are already in place.
