I'm Vincent Pradeilles. I'm a software engineer, and at Photoroom I work on product and developer relations. My job is to explore the technology our engineering team ships, talk with the people who use it, and turn what I learn into something that has an actual impact on their business.
Virtual try-on is a good example. It lets a shopper see a piece of clothing on themselves, from a single selfie, before they buy. You can add it to product pages, product grids, emails and push notifications with one API call. Getting it working is the easy part. Getting it right is harder: the fit has to match the size the shopper would actually receive, and details like the logo have to look exactly like the real thing. In this post, I'll walk you through where virtual try-on fits on your store, how the integration works, and the two pitfalls you really want to avoid.
Why do shoppers need virtual try-on?
Because most product pages make it hard to picture yourself wearing the item, and that happens in two ways.
Sometimes there's simply no photo of the item being worn. A retailer may not have had time to shoot every product, or ran a shoot years ago and has since lost the rights to the model's likeness. On second-hand marketplaces, it's the norm: sellers photograph items at home with their phone, and modelling the clothes themselves is a lot of effort (and a bit awkward), so most don't bother.
Sometimes there is a photo, but the model looks nothing like you. A shirt on a tall professional model doesn't tell you much about how it'll look on you.
Either way, the shopper is left guessing. That's the unfair advantage of a physical store: you can pick the item up, try it on and see how it looks on you. Online, the only way to do that is to order it, and send it back if it's wrong. Virtual try-on closes a big part of that gap.
Where can you add virtual try-on on your store?
Anywhere you show a product image. Here are the four places I'd start with.
1. The product page. Add a "Try it on" button. The shopper takes a selfie or picks a photo from their camera roll, and a few seconds later they're looking at themselves wearing the item. When I tested it, I took a selfie with my laptop webcam in the office, with zero effort on lighting, which is exactly what a real shopper would do. Seeing myself in the green sweatshirt made it far easier to judge the fit, the fabric and how the color works with my hair and skin tone than staring at a flat-lay photo.
:no_upscale():format(webp))
2. The product grid. You already have the shopper's selfie, so reuse it to generate a try-on for every item on a category page. The result is a product grid that's fully personalized to them.
:no_upscale():format(webp))
3. Emails. You only need the selfie once. Save it, and you can reuse it everywhere, including in your CRM (the tool that sends your marketing emails). When someone views a product or leaves something in their basket, the follow-up email can show them wearing that exact item. That's a lot more eye-catching than the standard product photo.
:no_upscale():format(webp))
4. Push notifications. Push notifications have supported images for years. A "this could look good on you" message, with the shopper actually wearing the item, is hard to scroll past.
How does the virtual try-on API work?
It's simpler than you might think. You send two kinds of image and get one back:
The clothing item. One image is enough, but send more when angles matter. For shoes, you'll want every side. For a garment, the front and the back, depending on the pose you want.
The shopper. Their selfie or photo.
The API returns an image of that person wearing the item. From there, you can show it wherever it makes the most sense on your store.
Here's the minimal call:
curl -X POST https://image-api.photoroom.com/v2/edit \
-H "x-api-key: YOUR_PHOTOROOM_API_KEY" \
-F "imageFile=@clothing-item.jpg" \
-F "virtualModel.mode=ai.auto" \
-F "virtualModel.model.custom.imageFile=@shopper-selfie.jpg" \
-o virtual-try-on-result.pngExtra angles of the same item go in virtualModel.additionalProductImages[]. Output is 1K by default, with 2K and 4K available on Enterprise plans (virtual try-on docs).
Honestly, you don't need to write much of this by hand anymore. Point a coding agent at the virtual try-on documentation and it'll build you a working prototype.
How accurate is virtual try-on on garment fit and size?
By default, not accurate enough. The good news: give the model the item's size or measurements, and it gets a lot better.
To test this, I bought two t-shirts from the same store, one in size S and one in L. I photographed both on a table with my phone, the way someone reselling them would, and ran a try-on on the same person.
Both came back with exactly the same fit. That doesn't make sense: put the same person in an S and an L, and the L should look obviously bigger.
Here's why. Left to its own devices, an AI image editing model makes the garment fit the person nicely. That's great for aesthetics, but bad for e‑commerce, where what you need is realism. The shopper has to see what they'll actually get if they order that size.
Fix 1: pass the measurements. As soon as I added the real measurements of each t-shirt, the difference was obvious: the L hung larger than the S, as it should. If you're a retailer, chances are you already have these measurements, maybe even in the size guide on your product page. On a self-serve API plan, add them as text in the virtualModel.prompt parameter. On an Enterprise plan, a Visual Agent set up for your catalog can handle this for you.
:no_upscale():format(webp))
Fix 2: pass the size label. No measurements? The size label alone already helps a lot. I took a photo of an XL t-shirt from a second-hand marketplace. With the image only, the try-on on a woman of average build fit far too neatly. Once I added "XL" to the prompt, the fit became realistic: looser and longer, the way an XL actually hangs.
:no_upscale():format(webp))
This matters for your margins as much as for the experience. A try-on that flatters the shopper sets the wrong expectation, and the last thing you want is a customer who opens the parcel, finds it doesn't look like what they saw, and sends it straight back.
How do you keep logos and product details accurate?
The same models that invent a flattering fit also tend to get the fine details wrong, and on clothing, the fine details are often the brand's logo. When I ran a puffer jacket through a general AI editing model, the logo came out smudged and garbled. To a shopper, that looks like a fake, which is the opposite of what you want on a product page.
At Photoroom, we built a Fidelity Layer to fix exactly this. It sits on top of the image model, compares the generated image with the original product photo, spots where the fine details differ, and guides a corrected generation (Photoroom product fidelity benchmark). On my puffer jacket, the logo came out clean. I think it's pretty obvious which version you'd rather show your shoppers.
:no_upscale():format(webp))
The Fidelity Layer is an opt-in option of Visual Agents on Enterprise plans. It isn't part of the self-serve API yet.
If you want the numbers, we ran a thorough benchmark, published in July 2026: 850 products, 4,250 generations, each checked by at least three trained reviewers. A generation only passed if nobody flagged a fidelity problem.
Setup (2K output) | Generations with no fidelity issues |
Nano Banana 2 + Photoroom Fidelity Layer | 38.2% |
Nano Banana 2 | 29.0% |
Nano Banana Pro | 28.2% |
GPT Image 2 Medium | 27.2% |
FLUX.2 Klein 9B | 16.8% |
Long story short: the Fidelity Layer took Nano Banana 2 from 29.0% to 38.2%. That's 9.2 percentage points, or about a third more clean results (benchmark).
What else can you do with virtual try-on?
Before you go, here are two ideas that take things a step further than a standard try-on.
Use a lookalike model. Let's be honest, it's always a bit strange to see yourself in a picture, and seeing yourself all over a product grid can be a lot. Instead, you can use the selfie to create a lookalike: someone with the same build, haircut, hair color and skin tone, but a different face. I tried it on myself, and the result looked like me without being me, which I found much easier to look at. On a self-serve API plan, you can build this with Edit With AI. On an Enterprise plan, it can be packaged into a Visual Agent.
:no_upscale():format(webp))
Real-time try-on. This is the one I'm personally most excited about. At Photoroom Labs, we're actively working on try-on as a live video feed instead of a single image. In my tests, I could move around and see the room's lighting on the garment, first in a hotel room and then in my own living room, where I could see how a jacket looked on me somewhere I know well. It's the best of both worlds: everything a fitting room gives you, from the comfort of your home.
Try it out
The virtual try-on documentation has everything you need to build a prototype. If you'd rather see the feature in action first, open virtual try-on. For on-model images across your whole catalog, take a look at the Virtual Model API. And if you'd like to talk about rolling it out on your store, I'm always happy to chat: email me at vincent.pradeilles@photoroom.com.
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))
:no_upscale():format(webp))