What does the color separation API return?

For each request it returns the detected spot inks (hex), one grayscale film-positive PNG per ink, and a composite print-simulation preview, plus a screen-vs-DTF recommendation and your remaining credit balance.

How is the API priced?

Two ways: pay-as-you-go credit packs that never expire, or a monthly plan with a separation allowance. One separation = one credit. You can mix both — the monthly allowance is spent first, then pack credits.

Can I control the halftone and ink settings through the API?

Yes. Every control on the desktop app's halftone, tone and mixing, white underbase, trapping and highlight white panels is an optional JSON parameter: LPI, mesh, screen angle set, DPI, dot gain, min and max dot, spot versus simulated process, underbase choke and minimum coverage, auto-trap strength, registration marks, saturation gamma, winner boost, suppress below, ink budget, GCR, UCR, and the highlight white brightness, saturation, choke and halftone options. All are optional and default to the values the browser app uses, so sending only an image still gives a sensible separation. The response echoes back every setting it resolved.

DTF and screen-print shops separating at volume, print-on-demand platforms that want automatic separations in their own app, and developers integrating prepress into a larger workflow.

Is there still a one-time desktop app?

Yes. The $179 one-time AI Separations desktop app is for individual shops and includes AI background removal, upscaling, and the Separation Advisor. The API is for programmatic, high-volume, or platform use.

For shops, platforms & developers

Color separation, as an API

POST a piece of artwork and get back press-ready spot inks, a film-positive for every ink, and a composite preview — in one request. Meter it by credit: pay-as-you-go or a monthly plan.

See pricing Read the docs

Quickstart

Send a base64 image and your key. One separation = one credit.

POST /api/separate

curl -X POST https://www.aiseparations.com/api/separate \
  -H 'X-API-Key: sk_live_...' \
  -H 'Content-Type: application/json' \
  -d '{"image":"data:image/png;base64,iVBOR...","colors":6,"garment":"dark"}'

200 OK — response

{
  "count": 6,
  "colors": ["#100c09", "#542a1d", "#963c26", "#c88756", "#fbfafa"],
  "composite": "data:image/png;base64,...",   // print-simulation preview
  "plates": [{"ink":"#100c09", "image":"data:image/png;base64,..."}, /* one film-positive per ink */ ],
  "recommend": "screen",          // "screen" or "dtf"
  "photographic": false,        // measured from the art, not the ink count
  "remaining": 199,

  // every setting the request resolved to, echoed back
  "mode": "sim", "lpi": 55, "dpi": 300, "angle_set": "Spot 15° offset (default)",
  "choke": 1, "trap": 0, "ub_min_cov": 8.0, "regmarks": false,
  "saturation": 0.85, "winner_boost": 0.2, "suppress_below": 0.08,
  "ink_budget": 1.4, "gcr": 0.0, "ucr": 0.0,
  "highlight": false, "hw_halftone": false
}

Endpoints

POST /api/separate — separate an image (consumes 1 credit)

GET /api/credits — check your balance (free), header X-API-Key

Parameters

All fields go in the JSON body; only image is required. Every knob below is optional and defaults to the values the browser app uses, so {"image": "..."} alone gives you a sensible separation. Values outside a listed range are clamped, not rejected. Images up to 12 MB.

Core

Param	Type	Default	What it does
`image`	string	—	Required. Base64 PNG/JPG/WEBP, raw or as a `data:` URL.
`colors`	int 2–12	auto	Target ink count. Omit to let the engine pick the plates a printer would actually burn.
`garment`	"dark" \| "light" \| color name \| "#rrggbb"	"dark"	The shirt the art prints on. "dark" = black, "light" = white; or a color name (Navy, Royal, Red, Maroon, Forest, Kelly Green, Gold, Orange, Purple, Heather Grey, Charcoal, Light Blue, Pink, Sand) or any hex. The separation is solved against that exact shirt color: inks that match the shirt are dropped (the shirt shows through), and the preview is drawn on it.
`underbase`	bool	auto	Print a choked white underbase. Default: on for shirts darker than mid-grey ("dark", Navy, Red...), off for light ones ("light", Gold, Heather Grey...).
`mode`	"sim" \| "spot" \| "index" \| "cmyk" \| "gray" \| "dtf"	"sim"	Simulated process halftones every ink (photos, gradients). Spot prints each plate solid — crisp edges for logos and flat vector art. Index prints one ink per square pixel with no halftone and no overlap. CMYK is 4-color process; gray is one screen (black ink on light shirts, white ink on dark); DTF preps a transparent print file plus a white layer.
`index_ppi`	int 50–400	150	Index mode only (`mode: "index"` — one ink per square pixel, no halftone): index pixels per inch.

Halftone & film output

Param	Type	Default	What it does
`lpi`	int 25–80	55	Halftone line frequency — dot fineness.
`mesh`	int	—	Convenience: 110, 156, 200, 230, 280, 305 or 355 sets the `lpi` that mesh can hold (35/45/50/55/60/65/70). Ignored if you send `lpi` yourself.
`angle_set`	string	"Spot 15° offset (default)"	Screen angles, cycled across plates. Also accepts `"CMYK process (15/75/0/45)"` and `"Wide 30° spacing"`. Wider spacing is extra moiré safety on coarse mesh.
`dot_shape`	"round" \| "elliptical" \| "line" \| "square" \| "diamond"	"round"	Halftone dot shape for every screened plate. Elliptical smooths midtones (skin, gradients); the non-round shapes hold exact coverage at every tone.
`dpi`	int 150–1200	300	Output resolution of the film positives.
`dot_gain`	float 0–40	18	Percent dot-gain compensation — pre-shrinks dots for ink spread on press.
`min_dot`	float 0–30	0	Percent. Smallest printable highlight dot; below it, coverage drops to zero instead of flashing an unholdable dot.
`max_dot`	float 70–100	100	Percent. Caps shadow coverage so dark areas don't plug.
`regmarks`	bool	false	Stamp identical crosshair registration targets on every plate.
`job_info`	bool	false	Simulated process and spot: adds a strip under every film (which screen, its place in the print order, angle, LPI, suggested mesh, and an 11-step grayscale wedge at that plate's angle) and returns a `job_sheet` image. `job_name` (string) labels it. The response always includes `print_order`.

Tone & mixing (simulated process only)

Param	Type	Default	What it does
`saturation`	float 0.1–1.5	0.85	Gamma on each ink channel. Lower pulls colors apart harder — richer, more saturated.
`winner_boost`	float 0–1	0.2	Extra coverage pushed onto each pixel's dominant ink, toward solid.
`suppress_below`	float 0–0.5	0.08	Zero out any ink coverage under this — kills color speckle.
`ink_budget`	float 0.4–3	1.4	Max total ink coverage on a single pixel, summed over all plates (1.4 = 140%). Keep it above 1 or no plate can print solid.
`gcr`	float 0–1	0	Gray Component Replacement — carries the neutral built by overlapping colors on the black plate instead. Saves ink, cleaner neutrals.

These five shape continuous tone, so mode: "spot" ignores them — solid plates have no tone to redistribute. gcr additionally needs a near-neutral black ink in the palette to carry the gray, plus at least two other chromatic inks to pull it from; if the darkest ink is saturated (a navy or maroon) it no-ops rather than muddying the art — the same rule the desktop app applies.

Underbase & trapping

Param	Type	Default	What it does
`choke`	int 0–4	1	Pixels the white underbase is pulled inward, so it tucks under the colors and can't peek out.
`ub_min_cov`	float 0–60	8	Minimum ink coverage (0–255) before the underbase fires under a pixel.
`ucr`	float 0–1	0	Under-Color Removal — thins the white underbase beneath heavy black. Softer hand, less buildup. Needs a near-neutral black ink in the palette; works in both modes.
`trap`	int 0–3	0	Auto-trap strength in pixels. Dark inks spread, light inks choke, so a registration miss doesn't leave a hairline of bare shirt.

choke, ub_min_cov and ucr only do anything with garment: "dark" — a light garment gets no underbase to shape.

Highlight white (top pass · dark garments only)

Param	Type	Default	What it does
`highlight`	bool	false	Add a white plate printed on top of the colors to recover true whites.
`hw_brightness`	float 0.5–1	0.85	How bright a pixel must be to receive top white. Higher = only the very brightest spots.
`hw_max_sat`	float 0–1	0.18	Saturation ceiling. Vivid brights (a strong yellow) are excluded — their own plate handles them.
`hw_choke`	int 0–6	2	Choked harder than the underbase — it's the last screen down, so registration error has compounded.
`hw_halftone`	bool	false	Fade highlights with dots on the next free screen angle instead of one hard solid white.

The response echoes back every setting it resolved (lpi, angle_set, gcr, ub_min_cov, …) so you can log exactly what produced a given set of plates.

Pricing

One separation = one credit. Mix both models — your monthly allowance is spent first, then pack credits never expire.

Pay as you go

Sample

$29

10 separations · $2.90 ea

Credits never expire
Full API access

Get started

BEST VALUE

Shop

$99

50 separations · $1.98 ea

Credits never expire
Full API access

Get started

Monthly plans

Plan	Separations / month	Price	Effective
Lite	150	$29/mo	$0.19 ea	Subscribe
Pro	750	$99/mo	$0.13 ea	Subscribe
Scale	3,000	$299/mo	$0.10 ea	Subscribe

Need higher volume, an SLA, or on-prem? Talk to us.

Who it's for

DTF & screen-print shops separating at volume — automate the prep step.
Print-on-demand platforms — offer automatic separations inside your own app.
Developers / integrators — drop prepress into a larger order pipeline.

Prefer a one-time app?

The AI Separations desktop app is $179 one-time and adds AI background removal, upscaling, the Separation Advisor, instant quoting, and ink matching — built for individual shops. Or try it live in your browser first.