# Garment Photo to Virtual Try-On Lookbook (`seasons-ai/garment-tryon-lookbook`) Actor

Turn one garment photo into an on-model lookbook worn by original AI-generated models. Pay per look delivered; failed looks are free.

- **URL**: https://apify.com/seasons-ai/garment-tryon-lookbook.md
- **Developed by:** [Stan Lookoff](https://apify.com/seasons-ai) (community)
- **Categories:** AI, E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $450.00 / 1,000 look with ai models

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Garment Photo to Virtual Try-On Lookbook — On-Model Images from One Photo

Turn one garment photo into a ready-to-use lookbook: your piece worn by **original AI-generated models** in different poses, body types and scenes. No photo shoot, no model releases, no setup.

### What you can do

- **On-model images from a flat-lay:** give a packshot, flat-lay or hanger shot and get the garment worn by a model.
- **A whole lookbook in one run:** 1–10 looks, each with a new fictional model and a different pose.
- **Pick the audience and scene:** women, men or mixed; studio, street, nature, interior, mixed — or describe your own scene.
- **Share it as one page:** every run also builds `lookbook.html` with all looks side by side.
- **Use your own models (optional):** try the garment on your own model photos, with consent confirmed.
- **Automate it:** call it from the API, schedules, n8n, Make or an AI agent via Apify MCP.

Built for fashion e-commerce, Etsy and print-on-demand apparel sellers who need on-model images fast.

### How to use

1. Paste a direct link to your garment photo and pick the garment type.
2. Choose the number of looks, the models (women, men or mixed) and a scene.
3. Start the run. When it finishes, open the **Output** tab: one row per look (`imageUrl`) and a link to the lookbook page.

Each look takes roughly 30–90 seconds; two looks are made in parallel.

#### About the models

By default every model is AI-generated and fictional — no real person's likeness is used. Models vary in skin tone, age and body type.
You can optionally supply your own model photos (Advanced section). This requires ticking the consent box confirming every pictured person agreed; without it the run stops before anything is generated.

### Pricing

You pay per look delivered. **Failed looks are free.**

| Event | When | Price per look | 1 look | 6-look lookbook |
|---|---|---|---|---|
| `look-rendered` | AI-generated model (default) | **$0.45** | $0.45 | $2.70 |
| `look-rendered-own-model` | Your own model photo (consent confirmed) | **$0.35** | $0.35 | $2.10 |

A typical run of 3 looks with AI models costs **$1.35**.
Before generating, the Actor checks that your run's maximum cost covers `looks × price`. If it doesn't, the run stops without spending anything and tells you the amount to set.

Available on paid Apify plans.

### Input example

```json
{
  "garmentImageUrl": "https://upload.wikimedia.org/wikipedia/commons/0/0f/T-shirt2.jpg",
  "garmentType": "top",
  "garmentDescription": "white cotton crew-neck t-shirt",
  "looks": 2,
  "audience": "mixed",
  "scene": "studio"
}
```

| Field | Description | Default |
|---|---|---|
| `garmentImageUrl` | Direct link to a JPEG, PNG or WebP garment photo (required) | — |
| `garmentType` | `top`, `bottom`, `dress`, `outerwear`, `full-outfit` | `top` |
| `garmentDescription` | Short description, e.g. "white cotton crew-neck t-shirt" | — |
| `looks` | Number of looks, 1–10 | `3` |
| `audience` | `mixed`, `women`, `men` | `mixed` |
| `scene` | `studio`, `street`, `nature`, `interior`, `mixed` | `studio` |
| `customScene` | Your own scene text (overrides `scene`) | — |
| `outputFormat` | `jpeg` or `png` | `jpeg` |
| `seed` | Optional seed for repeatable results | — |
| `ownModelPhotoUrls` | Optional: your own model photos, one look each (max 10) | — |
| `ownModelConsent` | Required `true` when you add your own model photos | `false` |

### Output example

One dataset row per delivered look:

```json
{
  "look": 1,
  "imageUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/look-01.jpg",
  "modelImageUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/model-01.jpg",
  "garmentImageUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/garment.jpg",
  "garmentType": "top",
  "model": "ai-generated",
  "modelDescription": "a woman in her late 20s with deep brown skin, short natural curly hair, athletic build",
  "pose": "standing straight facing the camera, arms relaxed at the sides",
  "scene": "in a professional photo studio with a seamless light grey backdrop, soft even lighting",
  "width": 800,
  "height": 1184,
  "megapixels": 0.947,
  "priceUsd": 0.45,
  "lookbookUrl": "https://api.apify.com/v2/key-value-stores/<storeId>/records/lookbook.html"
}
```

The key-value store also holds `lookbook.html` (all looks on one page), every `look-NN` image, the base model shots and `OUTPUT` with a run summary.

### Limits

- 1–10 looks per run; up to 10 own model photos per run.
- Look images are about 0.95 MP (800 × 1184 for AI models). Your own model photos are scaled down to at most 0.98 MP before the try-on.
- Garment photo: JPEG, PNG or WebP, up to 25 MB.

### Good to know

- One garment per photo on a plain background gives the best results. Small prints, logos and text on the garment can come out slightly changed — check each look before using it.
- Content filters may reject some garments or photos; rejected looks are not charged.
- Files stay available while the run's storage is kept (your plan's retention period) — download them to keep them.
- Questions or a missing option? Open an issue on the Actor page.

# Actor input Schema

## `garmentImageUrl` (type: `string`):

Direct link to a JPEG, PNG or WebP photo of the garment (flat-lay, packshot or hanger shot). One garment per photo works best.

## `garmentType` (type: `string`):

What kind of piece it is. Used to dress the generated models in neutral basics that do not clash with your garment.

## `garmentDescription` (type: `string`):

Optional short description, e.g. "white cotton crew-neck t-shirt, relaxed fit". Helps the try-on keep the right fit and fabric. Max 200 characters.

## `looks` (type: `integer`):

How many looks to generate (1-10). Each look is a new AI-generated model in a different pose. You pay per look delivered.

## `audience` (type: `string`):

Which models to generate. "Mixed" alternates women and men. Models always vary in skin tone, age and body type.

## `scene` (type: `string`):

Background for the shots. "Mixed" rotates through all scenes.

## `customScene` (type: `string`):

Optional. Overrides the scene above, e.g. "sunlit beach boardwalk at golden hour". Max 200 characters.

## `outputFormat` (type: `string`):

Format of the look images.

## `seed` (type: `integer`):

Optional. Same seed and inputs give similar results across runs.

## `ownModelPhotoUrls` (type: `array`):

Leave empty to use original AI-generated models (recommended). Only add photos of real people if you have their consent and tick the box below. One look per photo; the number of looks above is then ignored. Max 10.

## `ownModelConsent` (type: `boolean`):

Required when you add your own model photos. By ticking this you confirm you have the right and the consent of each pictured person to create try-on images of them.

## Actor input object example

```json
{
  "garmentImageUrl": "https://upload.wikimedia.org/wikipedia/commons/0/0f/T-shirt2.jpg",
  "garmentType": "top",
  "garmentDescription": "white cotton crew-neck t-shirt",
  "looks": 2,
  "audience": "mixed",
  "scene": "studio",
  "outputFormat": "jpeg",
  "ownModelConsent": false
}
```

# Actor output Schema

## `looks` (type: `string`):

No description

## `lookbook` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "garmentImageUrl": "https://upload.wikimedia.org/wikipedia/commons/0/0f/T-shirt2.jpg",
    "garmentDescription": "white cotton crew-neck t-shirt",
    "looks": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("seasons-ai/garment-tryon-lookbook").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "garmentImageUrl": "https://upload.wikimedia.org/wikipedia/commons/0/0f/T-shirt2.jpg",
    "garmentDescription": "white cotton crew-neck t-shirt",
    "looks": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("seasons-ai/garment-tryon-lookbook").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "garmentImageUrl": "https://upload.wikimedia.org/wikipedia/commons/0/0f/T-shirt2.jpg",
  "garmentDescription": "white cotton crew-neck t-shirt",
  "looks": 2
}' |
apify call seasons-ai/garment-tryon-lookbook --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,seasons-ai/garment-tryon-lookbook"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/zQDSVYPEEez3r4l5a/builds/eMrJuy2bNu8qcKEEL/openapi.json