REST API · Live

VTON API vs Veesual — Virtual Try-On for Fashion Ecommerce

Looking at a VTON API vs Veesual comparison? PixelAPI gives you a developer-ready virtual try-on REST endpoint at $0.025 per image — no sales call, no 4-week onboarding, no minimum contract. POST a garment image and a model photo; get a dressed result back in under 30 seconds. Veesual and Zyler require enterprise agreements; PixelAPI ships an API key in 60 seconds. 500 free credits, no credit card required.

$0.025 / try-on ~30s typical 500 free credits No credit card upperbody · lowerbody · dress Webhook callbacks
Get an API key (free) Quick start See pricing API docs

Quick start — one API call to virtually try on a garment

Sign up, copy your key from the dashboard, and POST a JSON body with two base64-encoded images. The endpoint returns a job_id; poll until status=completed, then download the try-on result.

# Step 1 — submit the try-on job
curl -X POST https://api.pixelapi.dev/v1/virtual-tryon \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "garment_image": "'$(base64 -w0 garment.jpg)'",
    "person_image":  "'$(base64 -w0 model.jpg)'",
    "category": "upperbody",
    "n_samples": 1
  }'
# Response: {"job_id": "uuid", "status": "queued", "eta_seconds": 30, ...}

# Step 2 — poll until completed
curl https://api.pixelapi.dev/v1/virtual-tryon/jobs/UUID \
  -H "Authorization: Bearer YOUR_API_KEY"
# Response: {"status": "completed", "output_url": "https://...", ...}
pip install pixelapi
---
from pixelapi import PixelAPI

client = PixelAPI(api_key="YOUR_API_KEY")
result = client.virtual_tryon(
    garment_image="garment.jpg",
    person_image="model.jpg",
    category="upperbody",   # upperbody | lowerbody | dress
    n_samples=1,
)
result.save("tryon_result.jpg")
npm install pixelapi
---
import { PixelAPI } from "pixelapi";
import fs from "fs";

const client = new PixelAPI({ apiKey: process.env.PIXELAPI_KEY });
const result = await client.virtualTryon({
  garmentImage: fs.readFileSync("garment.jpg"),
  personImage:  fs.readFileSync("model.jpg"),
  category:     "upperbody",
  nSamples:     1,
});
await result.save("tryon_result.jpg");
composer require pixelapi/pixelapi
---
<?php
use PixelAPI\Client;

$client = new Client(getenv("PIXELAPI_KEY"));
$result = $client->virtualTryon([
    "garment_image" => base64_encode(file_get_contents("garment.jpg")),
    "person_image"  => base64_encode(file_get_contents("model.jpg")),
    "category"      => "upperbody",
    "n_samples"     => 1,
]);
file_put_contents("tryon_result.jpg", $result->getBody());
gem install pixelapi
---
require "pixelapi"
require "base64"

client = PixelAPI::Client.new(api_key: ENV["PIXELAPI_KEY"])
result = client.virtual_tryon(
  garment_image: Base64.strict_encode64(File.read("garment.jpg")),
  person_image:  Base64.strict_encode64(File.read("model.jpg")),
  category:      "upperbody",
  n_samples:     1
)
File.binwrite("tryon_result.jpg", result.body)
go get github.com/pixelapi/pixelapi-go
---
import "github.com/pixelapi/pixelapi-go"

client := pixelapi.New("YOUR_API_KEY")
result, err := client.VirtualTryon(pixelapi.VTONRequest{
    GarmentImage: "garment.jpg",
    PersonImage:  "model.jpg",
    Category:     "upperbody",
    NSamples:     1,
})
if err != nil { panic(err) }
result.Save("tryon_result.jpg")

Pricing — VTON API vs Veesual, Zyler, FASHN AI, and others

Every rival in this space either hides its pricing behind enterprise sales or charges significantly more per image. Here's what's publicly verifiable:

ProviderFree tierPer-image costSetup requiredAPI access
PixelAPI 500 credits, no card $0.025 60-second signup REST + SDKs
FASHN AI Limited trial $0.075 (on-demand) · $0.049–0.068 (tiers) API key signup REST
Veesual None public Contact sales (enterprise) ~4-week onboarding Integration platform
Zyler None public Contact sales Custom integration Plug-in / API
CALA None public See cala.com/pricing Platform account Platform API
Outfit.ai None public See outfit.ai/pricing Enterprise only Contact sales

FASHN AI pricing verified from help.fashn.ai/plans-and-pricing/api-pricing, May 2026. Veesual and Zyler do not publish per-image API pricing. PixelAPI's per-image price is set at exactly half the cheapest verified on-demand rate in this category per our pricing principle.

Why developers choose PixelAPI over Veesual

Self-serve in 60 seconds

No demo call. No RFP. Sign up, get an API key, make your first request. Veesual requires a sales engagement and a multi-week deployment cycle before you write a single line of code.

Pay per image, not per seat

At $0.025 per try-on image you only pay for what you generate. There's no monthly platform fee, no per-seat licence, no minimums. Scale from 10 to 10,000 try-ons with zero contract renegotiation.

Three garment categories

The API supports upperbody (shirts, tops, jackets), lowerbody (trousers, skirts, shorts), and dress (full-length garments). Pass the category in your JSON body — no separate models to manage.

Async + webhook architecture

Virtual try-on is compute-intensive. The API returns a job_id immediately and notifies your webhook_url when done — no blocking HTTP calls, no timeout errors in your product UI.

Multi-sample per call

Set n_samples up to 4 to generate multiple garment-on-model variants in a single request. Ideal for A/B testing product images or populating a carousel without making four separate API calls.

Auto-refund on failure

If a try-on job fails for any reason, credits are automatically refunded. You never pay for a result that didn't complete successfully — no support ticket required.

What you get back

output_url — hosted image

A direct URL to the generated try-on image. Download it, serve it from your CDN, or display it in your product UI. Standard JPEG quality, preserving the model's original pose, lighting, and proportions.

result_image_b64 — inline base64

For pipelines that prefer not to make a second HTTP fetch, the completed job response also includes the image as a base64-encoded string. Decode and write directly to disk or stream to the browser.

Job metadata

Each job response includes credits_used, created_at, and completed_at timestamps for billing reconciliation and latency monitoring.

NSFW-filtered inputs

Both garment and person images pass through a safety layer before processing. Flagged inputs are rejected before any credits are deducted — no charge for blocked requests.

Request parameters reference

ParameterTypeRequiredDefaultNotes
garment_imagestringYesBase64-encoded JPEG/PNG/WebP, max 10 MB
person_imagestringYesBase64-encoded JPEG/PNG/WebP, max 10 MB
categorystringNoupperbodyupperbody · lowerbody · dress
n_samplesintegerNo11–4 output variants per call
n_stepsintegerNo401–50. Higher = more detail, slower.
image_scalefloatNo2.00.1–10.0 adherence to garment details
webhook_urlstringNoURL to receive completion POST

Common workflows

The Virtual Try-On API is the core of these production fashion ecommerce pipelines:

Fashion catalog generation

Automate model photography at scale. Try any garment on a set of reference models without a photoshoot.

Garment prep & cleanup

Remove styling artefacts from flat-lay product shots before feeding them to the try-on pipeline.

Eyewear & accessories

Combine virtual try-on with background removal for complete accessory styling workflows.

Shopify product images

Generate on-model variants of every SKU automatically when a new product is added to your Shopify store.

Model image enhancement

Combine try-on output with face restoration to produce magazine-quality model imagery at API speed.

Marketing agency automation

Deliver fresh on-model editorial imagery for client campaigns without repeated photo studio bookings.

Integrations

PixelAPI is a plain REST endpoint and integrates with every platform that can make HTTP requests:

Shopify

Trigger try-ons on product upload via a Shopify webhook and serverless function.

Make.com

No-code automation: use the HTTP module to call the VTON API inside a Make scenario.

Zapier

Zap a new Shopify product to PixelAPI and push the try-on result back to your media library.

Shopify + editing pipeline

Chain try-on → background removal → relight for full studio-ready product images automatically.

WooCommerce

WordPress plugin pattern to generate on-model imagery on product creation.

Zapier advanced

Multi-step Zap: fetch garment, call VTON API, upload result to Cloudinary or S3.

Comparison vs alternatives

vs Replicate

Replicate's virtual try-on models charge ~$0.10 per image on per-second compute billing. PixelAPI is ~4× cheaper with fixed per-image pricing — no GPU startup time surprises.

vs Photoroom

Photoroom focuses on background removal, not garment try-on. PixelAPI offers both at competitive per-image pricing within the same API key and dashboard.

vs API4AI

API4AI offers a virtual try-on endpoint but at higher on-demand pricing. PixelAPI's 500 free credits let you evaluate before committing — API4AI's free tier is limited to 100 lifetime uses.

vs DIY self-hosting

Self-hosting a try-on model requires significant infrastructure investment, model management, and ongoing maintenance. PixelAPI handles all of this; you pay $0.025 per image and focus on your product.

Rate limits & error handling

The virtual try-on endpoint allows 10 requests/minute on the free tier and 60 requests/minute on paid tiers. This is separate from other PixelAPI endpoints — you can run background removal and virtual try-on concurrently without sharing rate limit quota. Exceeding the limit returns HTTP 429 with a Retry-After header. Recommended pattern: exponential backoff starting at 2 s, doubling each retry up to 30 s. The Python and Node SDKs implement this automatically.

# Python SDK — automatic retry-on-429 for the VTON endpoint
from pixelapi import PixelAPI

client = PixelAPI(api_key="...", max_retries=4)
result = client.virtual_tryon(
    garment_image="garment.jpg",
    person_image="model.jpg",
    category="upperbody",
)  # auto-retries 429 with exponential backoff

Common HTTP status codes from the VTON endpoint:

StatusMeaningAction
200 (queued)Job accepted, processingPoll /v1/virtual-tryon/jobs/{job_id}
400Invalid input (not base64, wrong category, NSFW)Fix input and retry; no credits deducted
402Insufficient creditsTop up credits in the dashboard
413Image exceeds 10 MB limitCompress or resize input image
429Rate limit exceededRespect Retry-After header; use SDK
503Service temporarily unavailableRetry after 5–10 s

Frequently asked questions

How does the PixelAPI VTON API differ from Veesual?

Veesual is an enterprise platform requiring a 4-week onboarding engagement and custom pricing — there's no public per-image rate. PixelAPI's VTON API is a developer-first REST endpoint you can call from any language in minutes. You get 500 free credits on signup, no sales call, no minimum contract. Pricing is $0.025 per try-on image.

What does the virtual try-on API cost?

$0.025 per output image — 25 credits at $0.001/credit on the Starter plan. New accounts get 500 free credits (20 try-on images worth) with no credit card required. For reference, FASHN AI charges $0.075 per image on-demand; PixelAPI is approximately 3× cheaper for equivalent on-demand usage.

What garment categories does the virtual try-on API support?

Three categories: upperbody (shirts, jackets, hoodies, tops), lowerbody (trousers, skirts, shorts, jeans), and dress (full-length dresses, jumpsuits, coats). Pass the category parameter in your JSON request body. Defaulting to upperbody if omitted.

What image formats are accepted?

Both the garment image and person/model image must be base64-encoded JPEG, PNG, or WebP. Maximum file size is 10 MB per image. Data URL prefixes (data:image/jpeg;base64,…) are automatically stripped — you can pass either raw base64 or a data URL.

How do I call the virtual try-on API?

POST a JSON body to https://api.pixelapi.dev/v1/virtual-tryon with your Bearer token. Include garment_image and person_image as base64 strings plus a category. You'll receive a job_id. Poll GET /v1/virtual-tryon/jobs/{job_id} until status=completed. The result is in output_url or result_image_b64. See the Quick Start code above for all six language examples.

How long does a virtual try-on take?

The API returns an eta_seconds estimate of approximately 30 seconds for a single output sample. Most requests complete in 25–40 seconds end-to-end. For multiple samples (n_samples up to 4), budget roughly 30 × n_samples seconds. Use the webhook_url parameter to avoid polling in production.

Can I generate multiple try-on variants in one API call?

Yes. Set n_samples to 2, 3, or 4 to receive multiple distinct try-on outputs in a single request. Credits are charged as 25 × n_samples (so 4 variants = 100 credits = $0.10). This is useful for A/B testing colour or fit presentation, or for populating a product image carousel.

Does the API support webhook callbacks?

Yes. Pass a webhook_url in your request body. When the job completes or fails, PixelAPI will POST the final status JSON — including output_url and credits_used — to your endpoint. This avoids polling and is the recommended pattern for production fashion ecommerce pipelines.

What happens if a try-on job fails?

Credits are automatically refunded on failure — you never pay for a broken result. The poll response will show status: failed with an error_message. Simply fix the inputs (check image format, size, category) and retry. No support ticket or manual refund request required.

Is there a Python SDK?

pip install pixelapi. Official SDKs also available for Node.js (npm install pixelapi), PHP (Composer), Ruby (Gem), Go (go get), and a Java/Kotlin client. All SDKs handle authentication, job polling, webhook setup, and auto-retry on 429 errors out of the box — zero boilerplate for the async job pattern.

What rate limits apply to the VTON endpoint?

10 requests/minute on the free tier, 60 requests/minute on paid tiers. Rate limits on the VTON endpoint are independent of other PixelAPI endpoints. Higher throughput for batch catalog processing is available — email [email protected] with your expected volume. Exceeding the limit returns HTTP 429 with a Retry-After header.

Can I use PixelAPI's VTON API on Shopify or WooCommerce?

Yes. PixelAPI is a plain REST API that works with any platform capable of making HTTP calls. Shopify stores can trigger try-ons via a serverless function on product page load or on product creation via webhook. WooCommerce stores can integrate through a custom plugin or a Make.com/Zapier automation — see the integrations section above for setup guides.

Start free — 500 credits, no card Read full API docs Compare all plans