# Size Chart Maker (`coder_luffy/size-chart-maker`) Actor

Size Chart Maker that turns garment photos into graded measurement tables for any region, category, or size scale, so fashion brands, e-commerce sellers, and manufacturers get accurate size charts without manual measuring or tech packs. Generate accurate garment size charts from product images.

- **URL**: https://apify.com/coder\_luffy/size-chart-maker.md
- **Developed by:** [Luffy](https://apify.com/coder_luffy) (community)
- **Categories:** E-commerce, Integrations, AI
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Size Chart Maker

This Apify actor connects to the [Size Chart Maker](https://www.sizechart.shop/) AI engine. Give it a garment image and your sizing preferences and it returns a graded size chart with measurements for every size in your scale. Upload a file directly or paste a URL. One image per run.

Size Chart Maker is built by [Kawsar](https://twitter.com/kawsarlog) ([LinkedIn](https://www.linkedin.com/in/kawsarlog/)), founder of [Bigibyte](https://www.bigibyte.com/). This actor puts that same AI engine on the Apify platform, so you can trigger it from a workflow or pipe results into a spreadsheet or database.

**One image. One standard. Perfect fit everywhere.**

### What Size Chart Maker does

The AI looks at the garment in your image and returns a table of measurement points graded across your chosen size scale. Each measurement gets a letter label (A, B, C...), a plain-English name, a numeric value per size, and a tolerance. The format matches what factories and tech pack teams use.

Garment type is detected from the image itself: t-shirts, shirts, dresses, trousers, jackets, swimwear, kids clothing, and more. The measurement list adapts to what the AI sees, not a fixed template.

This actor processes one image at a time. For bulk catalog processing, use the original SaaS

### Use cases

#### For e-commerce sellers

- Generate professional-size charts for Shopify and WooCommerce product pages without hiring a designer
- Create size charts for Etsy listings for handmade and print-on-demand clothing, done in minutes
- Meet Amazon FBA size chart requirements automatically from a product photo
- Reduce clothing returns with accurate garment measurements: one seller reported a 35% drop after switching from guesswork to generated charts
- Build men's, women's, kids, and plus-size clothing size charts from a single reference image
- Create size charts for stretch fabrics, swimwear, denim, and footwear in any regional standard

#### For brands and manufacturers

- Convert a reference image or flat sketch to a size measurement table without writing a tech pack first
- Generate base size charts for new styles at the start of the design process, before patterns are final
- Give pattern makers and factories exact measurements from day one and cut buyer revision cycles
- Speed up garment sampling by removing the back-and-forth on size direction
- Build consistent size standards across multiple styles in your catalog
- Create size charts for merchandising teams from buyer photos or mood board images
- Avoid costly resampling caused by size errors caught late in production

#### Automate your sizing workflow

- Trigger size chart generation from a Shopify webhook when a new product is added
- Feed results directly into a Google Sheet or database alongside your product catalog
- Chain with a product scraper to generate size charts for an entire clothing line
- Use the Apify API to embed size chart generation in your own app or internal tool

### What is Size Chart Maker?

[Size Chart Maker](https://www.sizechart.shop/) is an AI-powered tool that turns garment photos into export-ready size charts in under 2 minutes. You upload a product image, pick your sizing region and garment category, and get back a full graded measurement table ready to download as Excel or PDF.

The platform covers US, UK, EU, JP, AU, CN, and International sizing across male, female, unisex, kids, plus-size, and tall categories. It has presets for common garment types including men's t-shirts, women's dresses, kids clothing, and formal suits, so you can go from image to chart without configuring every option from scratch. Images are deleted from the server immediately after processing.

For sellers who need size charts at scale, Size Chart Maker also has a Chrome extension and enterprise batch processing. This Apify actor gives you the same engine inside your automation workflows.

**Try the web app:** [sizechart.shop](https://www.sizechart.shop/)

**Contact:** info@sizechart.shop

### Input

#### Garment image

This actor processes one image per run. Provide it in whichever way fits your workflow:

| Field | Type | Description |
|-------|------|-------------|
| `imageUpload` | file | Upload a file directly from your computer through the Apify UI. Supports JPEG, PNG, WebP, GIF up to 20 MB. Easiest for one-off runs. |
| `imageUrl` | string | Public URL of the garment image. The actor downloads it automatically. A sample garment image is pre-filled so you can test the actor right away. |

Only one is needed. `imageUpload` takes priority if both are provided.

#### Sizing options

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `region` | string | `US` | Sizing region for the chart. Determines the grading rules applied. |
| `category` | string | `Unisex` | Garment category. Affects which measurements are included and how they are graded across sizes. |
| `unit` | string | `cm` | Measurement unit: `cm` or `in`. |
| `detailLevel` | string | `standard` | How many measurements to include. `basic` returns 4-5, `standard` returns 6-10, `full` returns a complete spec sheet with 12+ measurements. |
| `sizes` | array | `["S","M","L","XL","XXL"]` | The size labels to use as column headers. Enter one per line. Must match your chosen sizing region. |

##### Sizing region options

| Region | Typical labels | Common use |
|--------|---------------|-----------|
| US | XS, S, M, L, XL, XXL | North America, general global |
| UK | 8, 10, 12, 14, 16, 18 | UK women's numeric |
| EU | 36, 38, 40, 42, 44, 46 | European numeric |
| JP | S0, S1, S2, S3, S4, S5 | Japanese numeric |
| International | XXS, XS, S, M, L, XL | Generic global alpha |

You can pass any custom labels in `sizes` regardless of region, for example `["1X", "2X", "3X"]` for plus-size, `["2T", "3T", "4T"]` for toddlers, or `["28", "30", "32", "34"]` for jeans.

#### Example inputs

**Quick test with the sample image (US men's t-shirt):**

```json
{
    "imageUrl": "https://images.unsplash.com/flagged/photo-1585052201332-b8c0ce30972f?w=400",
    "region": "US",
    "category": "Male",
    "unit": "cm",
    "detailLevel": "standard",
    "sizes": ["S", "M", "L", "XL", "XXL"]
}
```

**Women's dress, EU numeric sizes:**

```json
{
    "imageUrl": "https://images.unsplash.com/photo-1515372039744-b8f02a3ae446?w=800",
    "region": "EU",
    "category": "Female",
    "unit": "cm",
    "detailLevel": "standard",
    "sizes": ["36", "38", "40", "42", "44", "46"]
}
```

**Kids' clothing, basic measurements, inches:**

```json
{
    "imageUrl": "https://images.unsplash.com/photo-1471286174890-9c112ffca5b4?w=800",
    "region": "US",
    "category": "Kids",
    "unit": "in",
    "detailLevel": "basic",
    "sizes": ["2T", "3T", "4T", "5T"]
}
```

**Plus-size with extended scale:**

```json
{
    "imageUrl": "https://images.unsplash.com/photo-1434389677669-e08b4cac3105?w=800",
    "region": "US",
    "category": "Plus",
    "unit": "cm",
    "detailLevel": "standard",
    "sizes": ["1X", "2X", "3X", "4X", "5X"]
}
```

### Output

The actor stores one dataset record per measurement row. Each record contains the measurement label, its name, a value for every size, the tolerance, and metadata from the run.

```json
[
    {
        "label": "A",
        "pointOfMeasure": "Body Length (HPS to Hem)",
        "S": 71,
        "M": 73,
        "L": 75,
        "XL": 77,
        "XXL": 79,
        "tolerance": "±1 cm",
        "region": "US",
        "category": "Male",
        "unit": "cm",
        "generatedAt": "2024-11-01T12:00:00+00:00"
    },
    {
        "label": "B",
        "pointOfMeasure": "Chest Width (1\" below armhole)",
        "S": 52,
        "M": 55,
        "L": 58,
        "XL": 61,
        "XXL": 64,
        "tolerance": "±1 cm",
        "region": "US",
        "category": "Male",
        "unit": "cm",
        "generatedAt": "2024-11-01T12:00:00+00:00"
    }
]
```

| Field | Type | Description |
|-------|------|-------------|
| `label` | string | Letter identifier for this measurement (A, B, C, ...) |
| `pointOfMeasure` | string | Name of the measurement point |
| `S`, `M`, `L`, ... | number | Graded measurement value for each size. Field names match exactly what you passed in `sizes`. |
| `tolerance` | string | Acceptable deviation from the nominal value, e.g. "±1 cm" |
| `region` | string | Sizing region used (US, UK, EU, JP, International) |
| `category` | string | Garment category the chart was generated for |
| `unit` | string | Unit for all numeric values: cm or in |
| `generatedAt` | string | ISO 8601 timestamp |

Size columns are dynamic. They always match exactly what you passed in `sizes`, so the output structure fits your run configuration without any fixed assumptions about size labels.

### How it works

1. The actor reads the garment image from whichever input you provide: a file upload or a URL.
2. The actor downloads and encodes the image before sending it to the service.
3. The encoded image and sizing options are sent to the Size Chart Maker service at [sizechart.shop](https://www.sizechart.shop/).
4. The service runs the AI analysis and returns a graded measurement table.
5. Each row is validated for required fields. Rows that fail are skipped with a warning in the log; valid rows are pushed to the dataset.
6. One dataset record is created per measurement row, with size columns added dynamically.

### FAQ

**Can I upload an image file directly?**
Yes. Use the `imageUpload` field in the Apify UI. Click the upload button, pick your image, and the actor handles everything else.

**Can I just test it quickly?**
Yes. The `imageUrl` field comes pre-filled with a sample garment image. Just set your sizing options and run.

**What image formats are supported?**
JPEG, PNG, WebP, and GIF. Maximum file size is 20 MB. For very large files, resize or compress before uploading.

**Can I use numeric size labels instead of alpha ones?**
Yes. Set `sizes` to any list of labels you need, for example `["36", "38", "40", "42"]` for EU, `["8", "10", "12", "14"]` for UK, or `["28", "30", "32", "34"]` for jeans. The output columns match exactly.

**What garment types does it support?**
The AI detects the garment from the image. It works with t-shirts, shirts, dresses, trousers, jeans, jackets, swimwear, kids clothing, plus-size garments, formal suits, and more.

**What happens if the service returns incomplete data?**
Rows missing required fields are skipped with a warning in the run log. The run does not fail for partial data. The final log line shows how many rows were pushed and how many were skipped.

**Is the image stored after processing?**
Size Chart Maker deletes images immediately after processing. See [sizechart.shop](https://www.sizechart.shop/) for the full privacy policy.

**Can I process multiple images in one run?**
This actor processes one image per run by design. For bulk catalog processing, contact [kawsarlog](https://twitter.com/kawsarlog) about enterprise access.

**What is a point of measure?**
A point of measure (POM) is a specific location on a garment where a measurement is taken, for example chest width at 1 inch below the armhole or body length from the high point shoulder to the hem. A size chart lists POMs as rows and sizes as columns, with a graded value at each intersection.

# Actor input Schema

## `imageUpload` (type: `string`):

Upload a garment image directly from your computer. Supported formats: JPEG, PNG, WebP, GIF (max 20 MB). This is the easiest option for most runs.

## `imageUrl` (type: `string`):

Public URL of the garment image. The actor downloads it automatically. The prefilled URL below is a sample garment image you can use to test the actor.

## `mimeType` (type: `string`):

Format of the image. Detected automatically when using file upload or URL.

## `region` (type: `string`):

The sizing standard to use for the output chart. US uses alpha labels (XS, S, M, L, XL, XXL). UK and EU use numeric sizes. JP uses Japanese numeric codes. International covers a general global alpha scale.

## `category` (type: `string`):

The target gender or fit category. Affects which measurements are included and how grading is applied across sizes.

## `unit` (type: `string`):

Unit for all numeric values in the output chart.

## `detailLevel` (type: `string`):

Controls how many measurements appear in the output. Basic covers essentials like chest and body length. Standard adds shoulder, sleeve, and neck. Full produces a complete spec sheet with 12 or more measurements.

## `sizes` (type: `array`):

The size labels to use as column headers in the output chart. Enter one label per line. Match these to your chosen sizing region (e.g. S M L XL for US, or 36 38 40 for EU).

## Actor input object example

```json
{
  "imageUrl": "https://images.unsplash.com/flagged/photo-1585052201332-b8c0ce30972f?w=400",
  "mimeType": "image/jpeg",
  "region": "US",
  "category": "Unisex",
  "unit": "cm",
  "detailLevel": "standard",
  "sizes": [
    "XS",
    "S",
    "M",
    "L",
    "XL",
    "XXL"
  ]
}
```

# 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 = {
    "imageUrl": "https://images.unsplash.com/flagged/photo-1585052201332-b8c0ce30972f?w=400",
    "sizes": [
        "S",
        "M",
        "L",
        "XL",
        "XXL"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("coder_luffy/size-chart-maker").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 = {
    "imageUrl": "https://images.unsplash.com/flagged/photo-1585052201332-b8c0ce30972f?w=400",
    "sizes": [
        "S",
        "M",
        "L",
        "XL",
        "XXL",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("coder_luffy/size-chart-maker").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 '{
  "imageUrl": "https://images.unsplash.com/flagged/photo-1585052201332-b8c0ce30972f?w=400",
  "sizes": [
    "S",
    "M",
    "L",
    "XL",
    "XXL"
  ]
}' |
apify call coder_luffy/size-chart-maker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,coder_luffy/size-chart-maker"
        }
    }
}

```

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/MSgzCfDw63Omcmngt/builds/92E8eiRLPOrJOL4zf/openapi.json