Best Virtual Try-On API in 2026: How to Choose the Right One
By Naveen Allem, Founder of TryOnCloud. Published 16 November 2026.
Search for the best virtual try-on API and you get lists. Lists are a fine place to start, but they cannot tell you how an API handles your catalogue, your shoppers' phone photos and your budget at full traffic. This guide does something more useful. It sets out the nine things that decide whether a try-on API is good, explains the three kinds of API on the market, and gives you a test plan and scorecard you can run in a single working day.
We build one of these APIs, so we are not neutral, and we say so. Everything about TryOnCloud below is a documented fact you can check in our docs, and the test plan works just as well for any other vendor.
The short answer
What a virtual try-on API actually does
A virtual try-on API takes two images, a garment and a person, and returns a new image of that person wearing that garment. It is not augmented reality and it is not a 3D body scan. Modern try-on APIs are generative: an image model reads the garment's shape, colour, print and fabric, reads the person's pose, face and body, and paints a photorealistic result. The output is a normal image you can show on a product page, in an app, on a kiosk screen or in a marketing email.
Behind that one call there is more work than the demo suggests. A good API prepares the garment (removing the model or mannequin it was photographed on), checks both images for content problems, keeps the shopper's face and body intact, handles partial body photos, and returns a clear error when an input cannot work. That hidden work is most of the difference between an API that looks good in a demo and one that holds up in production.


The 9 things that decide the best virtual try-on API
These are the criteria that separate APIs in real use. They are ordered by how much each one costs you when it goes wrong. Garment fidelity sits at the top because a try-on that changes your product sells the wrong item.
| Criterion | What to check | Why it matters |
|---|---|---|
| 1. Garment fidelity | The print, colour, logo, neckline, sleeve length and drape match the product photo. | A try-on that changes the product is worse than no try-on. Shoppers buy what they saw, then return what arrived. |
| 2. Identity preservation | The face, skin tone, hair and body shape stay the shopper's own. | If the person no longer looks like themselves, the image stops being useful for a buying decision. |
| 3. Category coverage | Tops, bottoms, dresses, full outfits, outerwear, plus your specialist categories (sarees, lehengas, abayas, kidswear rules). | Most catalogues are wider than the demo. One weak category means a broken button on a whole section of your store. |
| 4. Speed | Median and 90th percentile time from request to finished image. | A shopper on a phone waits about as long as a progress bar keeps them engaged. Check the slow tail, not only the average. |
| 5. Price per try-on at your volume | Cost per successful image, minimums, monthly fees, expiry, and what a failed request costs. | Per-image price looks small until it is multiplied by every curious visitor. Expiring credits quietly raise it. |
| 6. Integration shape | One synchronous call or a job plus polling, accepted inputs (file, URL, base64), clear error codes. | A single call that returns the image is the fastest to ship and the hardest to get wrong. |
| 7. Moderation and safety | Built-in checks for explicit uploads and photos of minors, with a distinct error code. | You are publishing generated images of real people. Moderation you have to bolt on yourself is moderation you will forget. |
| 8. Data handling | Whether person photos are stored, for how long, who processes them, and whether they train models. | Under GDPR and India's DPDP Act you are the controller. Your vendor's retention becomes your promise to your users. |
| 9. Licence and resale | Whether you may use results commercially and build the API into a product you sell. | Agencies and SaaS builders need white-label rights in writing before they sign a client. |
Garment fidelity deserves the most time
Zoom in. Compare the printed text on a T-shirt letter by letter. Check that a striped shirt keeps its stripe width, that a V-neck stays a V-neck and that a sleeveless dress does not grow sleeves. Look at the hem length relative to the knee. Most weak APIs fail quietly here: the result looks attractive at thumbnail size and wrong at full size, which is exactly the size a shopper looks at before buying.
Speed is a distribution, not a number
A vendor quoting "results in seconds" is describing a good request. Ask for the median and the 90th percentile, then measure them yourself from your own server, at the time of day your shoppers are active. The slowest one in ten requests is what a busy Saturday feels like. If an API's tail is long, design your interface so the shopper can keep browsing while the image is made, and notify them when it is ready.
Price only means something with its rules
Two APIs that both say "ten cents per image" can differ by a factor of two in practice. Credits that expire at the end of the month, a monthly minimum, or a charge for requests that fail all raise the real price. Divide everything you will pay in a month by the number of successful try-ons you will get. That is the only price worth comparing. Our virtual try-on API pricing guide walks through that calculation with worked examples.
Three kinds of virtual try-on API
Most options on the market fall into one of three groups. Knowing which group you are looking at tells you what the vendor will handle and what will land on your team.
| Type | What it is | Best for | Trade-off |
|---|---|---|---|
| Specialist try-on API | One endpoint built for clothing try-on, with garment preparation, moderation and support included | Stores, apps, agencies and kiosks that want a finished result | You depend on one vendor's model and roadmap |
| Model marketplace | A hosting platform that runs several try-on models from different authors behind one billing account | Teams that want to experiment with many models and handle quality themselves | Each model behaves differently; moderation, garment prep and support vary |
| Self-hosted open model | You download an open research model and run it on your own GPUs | Companies where try-on is the core product and an ML team already exists | GPUs, scaling, uptime, moderation and model updates are all on you |
None of these is the best for everyone. A research team exploring models will enjoy a marketplace. A fashion brand that needs a reliable button on every product page usually wants a specialist API, because garment preparation, moderation and support are what turn a model into a feature. A company whose entire product is try-on may eventually justify running its own models.
A test plan you can run in a day
The fastest way to find the best virtual try-on API for you is to send the same inputs to each candidate and compare. Plan on about eight hours for two or three APIs, most of it waiting for images and scoring them.
Step 1: build a test set from your own catalogue
Pick ten garments, weighted towards what you actually sell, and five person photos taken on ordinary phones. Include at least one photo in poor light and one cropped at the knees. Here is a set that exposes most weaknesses:
| Test garment | What it reveals |
|---|---|
| Plain T-shirt or shirt on a model | Baseline. Every API should pass this. If it fails here, stop. |
| Bold print or logo tee | Shows whether the API redraws or keeps the print. Zoom in on text and logos. |
| Dress or gown with a defined waist | Checks length, fit and how the skirt falls. |
| Full outfit, top plus bottom | Checks that both pieces arrive and nothing is invented. |
| Outerwear over a shirt | Checks layering: the jacket should sit over, not replace, what is under it. |
| Saree with a visible pallu | The hardest common garment. Pallu, border and pleats must survive. |
| Lehenga with dupatta | Heavy embroidery and a separate drape. |
| Flat lay or ghost mannequin photo | Many catalogues have no model shots. The API must work from these. |
| Person photo in poor light | Real shoppers use phones in bedrooms. See how it degrades. |
| Person photo cropped at the knees | Checks how the API handles a partial body without inventing legs badly. |
Step 2: call every API from your server
Do not judge an API by its playground. Call it from the same server you will use in production, with a 120 second timeout, and log the start time, end time, HTTP status, error code and cost of each request. Run each garment against each person photo. Ten garments and five people gives fifty results per API, enough to see patterns without spending much.
Step 3: score blind
Put the results in a folder with the vendor name hidden and score them with a colleague. Bias is real: once you know which result came from the vendor you already like, you will find reasons to forgive it.
Step 4: read the fine print
Before you commit, confirm in writing the price at your expected volume, whether credits expire, whether failed requests are charged, how long person photos and results are kept, whether inputs train the vendor's models, and whether you may use the API inside a product you sell to others.


Scorecard template
Fix the weights before you see any results, so the scoring cannot drift towards a favourite. These weights suit a clothing store or app. A kiosk operator might move weight from cost to speed, and an agency might add a row for resale rights.
| What you score | Weight | How |
|---|---|---|
| Garment fidelity (10 test garments) | 30% | Score each result 0 to 3, average, scale to 30 |
| Identity preservation | 15% | Same face, skin tone and body in every result |
| Category coverage for your catalogue | 15% | Pass or fail per category you sell |
| Median and p90 latency | 10% | Time 20 requests from your own server |
| Cost per successful try-on at your volume | 15% | Include minimums, fees, expiry and failed calls |
| Integration and errors | 5% | Hours to first working result, clarity of error codes |
| Moderation and data handling | 10% | Built in, documented, matches your privacy notice |
Anything that fails a hard requirement is out regardless of score. Typical hard requirements are support for your main category, data handling that matches your privacy notice, and a licence that allows your use.
How TryOnCloud's virtual try-on API measures up
Here is our API against the criteria above, in plain facts. Run it through the same test plan as everyone else; the free test mode lets you build the whole integration before you spend anything.
| TryOnCloud Developer API | |
|---|---|
| Endpoint | POST https://www.tryoncloud.com/api/v1/generate, one call, the finished PNG is the response body |
| Inputs | Garment as a file, public https URL or base64; person as a file or base64. JPEG, PNG, WebP or HEIC up to 15MB, checked by content |
| Price | $0.11 per try-on from 50, $0.10 from 300, $0.09 from 1,000, $0.07 from 5,000 (India: ₹9 to ₹6.50) |
| Billing rules | No subscription, credits never expire, failed try-ons refunded automatically, test mode always free |
| Speed | Median about 19 seconds, 90% within about 24 seconds (our docs, last 30 days); hard limit 120 seconds |
| Rate limit | 300 requests per minute per key, 600 per account |
| Garments | Western and Indian wear, including sarees, lehengas, kurtas and sherwanis; works from flat lays and model shots |
| Moderation | Built in, with distinct error codes for content problems, so your app can show the right message |
| Data | Person and garment photos processed in memory and not stored; results not stored unless you enable 7-day storage; never used for training |
| Resale | Allowed under your own brand, with one named key per client (up to 5 active) |
| Tooling | TypeScript SDK, MCP server for AI coding assistants, Markdown docs and llms-full.txt |
Three choices shape how the API feels to build on. First, it is one synchronous call: you send two images and the finished PNG is the response body, so there is no job queue to poll. Second, you pay only for images you receive, because failed generations are refunded before the error reaches you. Third, credits are a one-time purchase that never expires, so a quiet month does not cost you anything.
The same engine runs our Shopify app and our in-store try-on kiosk, which is why it is tuned for both Western and Indian wear, including draped garments that many models struggle with.


Other virtual try-on APIs developers compare
A fair guide names the alternatives. These are the names that come up most often when developers compare try-on APIs. We describe each only by what its own website says, and we do not link to them; check their current pages for prices and terms before you decide.
- FASHN presents itself as a fashion AI API for developers, with a REST API and TypeScript and Python SDKs, and says it covers clothing, shoes, bags, hats and jewellery at up to 4K.
- fal is a model hosting platform that lists a collection of virtual try-on models from different authors, billed through one account. It suits teams that want to try several models side by side.
- Genlook offers virtual try-on with a Shopify integration and publishes its own benchmark of try-on APIs.
- General image models from the large AI labs can also edit clothing onto a person when prompted. They are flexible, but you build the garment preparation, moderation and consistency checks yourself.
Benchmarks published by a vendor, including any we publish, are a starting point. The only benchmark that predicts your results is the one you run on your own catalogue.
Build your own model or use an API
Open research models for virtual try-on are available, and running one is a real option. It is worth being clear about what comes with it. You need GPUs sized for your peak traffic, not your average. You need garment preparation so that product photos with a model or mannequin still work. You need moderation for explicit uploads and photos of children, because you are generating images of real people. You need monitoring, model updates and a fallback when the model fails on a strange photo. And you need people who can do all of that.
For a store, an app or an agency, an API turns all of that into a per-image cost. For a company whose whole product is try-on, at very high and steady volume, owning the stack can make sense later. Most teams are best served by shipping with an API now and revisiting the decision when their monthly volume is large and predictable.
Integrate a virtual try-on API in under an hour
Whichever API you choose, the integration has the same shape. With TryOnCloud it looks like this:
curl -X POST https://www.tryoncloud.com/api/v1/generate \
-H "X-API-KEY: $TRYONCLOUD_API_KEY" \
-F "garment_image=@shirt.jpg" \
-F "person_image=@person.jpg" \
-o result.png- Create a key in the dashboard and keep it in an environment variable on your server.
- Build the flow with
mock=true, which validates everything, generates nothing and charges nothing. - Add a server route that receives the shopper's photo and the product image and calls the API with a 120 second timeout.
- Branch on the error
code, not the message, so each problem gets the right message for the shopper. - Buy a pack when you are ready for real traffic. The price drops automatically at 300, 1,000 and 5,000 credits.
Step-by-step guides are in the docs for Node.js, Python, PHP and Next.js. If you use Claude Code, Codex or Cursor, connect the MCP server and the assistant can read the docs and run real try-ons while it writes your integration. Our longer virtual try-on API integration guide covers the request and response in depth.
Mistakes that cost teams weeks
| Mistake | Do this instead |
|---|---|
| Testing with the vendor's demo images | Demo images are chosen to look good. Use your own catalogue and your own phone photos. |
| Comparing price per image without the rules | Expiring credits, monthly minimums and charging for failed calls can double the real price. |
| Calling the API from the browser | Your key ends up in the page source. Always call from your server or an edge function. |
| No timeout, or a short one | Generative try-on can take tens of seconds. Set a 120 second timeout and show progress. |
| Ignoring error codes | A content rejection, a bad photo and an empty wallet need three different messages for the shopper. |
| Forgetting the privacy notice | Tell users their photo is processed to create the try-on, and link your retention policy. |
Try the API on your own catalogue
Build the full integration free in test mode, then buy only what you use. From $0.07 per try-on, no subscription, credits never expire.
Head-to-head API comparisons
- TryOnCloud vs FASHN: price per image, speed, garment coverage and integration effort.
- TryOnCloud vs Genlook: sync and async calls, catalogue features and where each fits.
- TryOnCloud vs fal.ai: a managed try-on API compared with a model hosting platform.
Frequently asked questions
What is the best virtual try-on API?
The best virtual try-on API is the one that keeps the garment exactly as it is in your product photo, finishes fast enough that shoppers wait for it, and charges a price you can still afford at full traffic. For most clothing stores and apps that means a REST API with one call per try-on, built-in moderation, no subscription and clear data handling. TryOnCloud's API fits that brief at $0.07 to $0.11 per try-on with credits that never expire, but you should run the same test set through two or three APIs before choosing.
How much does a virtual try-on API cost?
Pricing is usually per generated image. TryOnCloud charges $0.11 per try-on for packs of 50 or more, $0.10 from 300, $0.09 from 1,000 and $0.07 from 5,000 (India pays ₹9 to ₹6.50). There is no monthly fee, credits never expire and failed try-ons are refunded automatically. See the full breakdown in our virtual try-on API pricing guide.
How fast is a virtual try-on API?
Generative try-on takes seconds, not milliseconds. TryOnCloud's docs report a median of about 19 seconds and 90% of requests within about 24 seconds over the last 30 days of production traffic, with a hard limit of 120 seconds. Ask any vendor for their median and 90th percentile, not just the best case.
Is there a free virtual try-on API?
TryOnCloud has a free test mode (add mock=true) that validates your full request without generating or charging, so you can build the whole integration for free. New accounts also get the free plan's 10 try-ons a month, which cover real API calls until you buy credits.
Which virtual try-on API works best for Indian wear like sarees and lehengas?
Test this directly, because many models are trained mostly on Western clothing. Send a draped saree, a lehenga with a dupatta and a kurta set, and check the pallu, borders and embroidery in the result. TryOnCloud is tuned for Indian and Western wear, and the API accepts any garment photo, including a flat lay or a photo of the garment on a model.
Can I resell a virtual try-on API under my own brand?
With TryOnCloud, yes. You may build the try-on into your own product and sell it to your clients under your own brand, with no TryOnCloud branding. Create one named API key per client so you can track and revoke each one separately. You may not share or resell the keys themselves.
Does a virtual try-on API store my customers' photos?
It depends on the vendor, so read their data page. TryOnCloud's API processes the person and garment photos in memory and does not write them to storage. The result comes back in the response body and is not stored unless you ask for result storage, which keeps results for 7 days. Photos are never used to train models.
Should I build my own virtual try-on model instead of using an API?
Only if try-on is your core product and you have an ML team, GPUs and months to spend. Open models exist, but you also need garment preparation, moderation, scaling, monitoring and a way to handle bad photos. For most stores and apps an API is faster to ship and cheaper until you reach very high volume.