# PNG to SVG Converter: Image Vectorizer for Cricut (`vncntlabs/png-to-svg-vectorizer`) Actor

PNG to SVG converter and image vectorizer: turn PNG, JPG and WEBP designs, logos and line art into clean SVG files in bulk. Full-colour SVG or single-colour cut files for Cricut, Silhouette and laser, 2-24 colours, background removal and speck cleanup. Also PDF, EPS and DXF. Commercial use OK.

- **URL**: https://apify.com/vncntlabs/png-to-svg-vectorizer.md
- **Developed by:** [vncntlabs Labs](https://apify.com/vncntlabs) (community)
- **Categories:** E-commerce, AI, For creators
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 image vectorizeds

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

## PNG to SVG Converter: bulk image vectorizer for Cricut, POD and laser

**Convert PNG to SVG in bulk.** This image vectorizer turns PNG, JPG and WEBP designs, logos, text and line art into clean SVG vector files, one image or thousands at a time. Get full-colour SVGs for printing and stickers, or single-colour cut files for Cricut, Silhouette, laser and vinyl, plus optional PDF, EPS and DXF.

Generic tracers give you hundreds of near-duplicate colour layers from anti-aliased edges, a white box around your design,
and wobbly curves full of nodes. This tool does the cleanup for you:

- **Real colours only.** The palette is detected from the flat areas of your design, so edge pixels don't become extra
  layers. You can also set a **max colour count** (e.g. 3 for a 3-colour vinyl job) or a **fixed palette** of your vinyl
  or ink colours.
- **Cricut-ready single colour.** One black compound path with clean holes (letters keep their counters). It imports as
  **one cut layer** in Design Space. Choose *silhouette* (the whole design, the usual pick for transparent PNGs) or *dark ink*
  (with an automatic or manual threshold, plus invert).
- **No background box.** Transparent PNGs stay transparent. A flat background colour touching the edge (white, for
  example) is removed automatically. White *inside* the design, such as eyes or the inside of letters, is kept.
- **Speck cleanup.** Removes dust, JPEG noise and tiny islands or holes up to a size you choose, so your blade doesn't
  have to cut confetti.
- **Smooth, light curves.** Outlines are traced exactly, then fitted with Bezier curves within a fixed tolerance. Circles
  stay round and straight edges stay straight. *Balanced*, *smooth* (fewest nodes), *sharp* and *polygon* styles are
  available, with advanced corner and tolerance controls.
- **Layers per colour.** Optionally get one non-overlapping compound path per colour, grouped and named by hex code.
  This is what you need for layered vinyl and screen-print separations.
- **Real-world sizes.** The SVG/PDF/EPS/DXF size is set in inches, mm or px, either from a width you give or from the
  source DPI (default 300).
- **AI upscale pre-pass (optional).** Small or blurry sources (under 1000 px) are first upscaled 4× with **Real-ESRGAN**,
  which gives cleaner edges and far fewer junk nodes. In our tests a 320 px logo came out with **half the nodes** and no
  halo colour.
- **Photo detection.** Photos don't vectorize well. Each image gets a photo score, and you can convert photos with a
  warning (a posterized flat-colour look, max 12 colours) or skip them for free.
- **Safe batches.** Each image gets one row with download links, its colours, node count and size. **Failed images
  are listed with the reason and never charged.** You can set a max cost per run, and the run stops cleanly when it
  reaches it.

### Who it's for

- Cricut, Silhouette and Glowforge crafters turning PNGs into cut files
- Etsy SVG-bundle sellers converting whole design folders
- Print-on-demand sellers (Merch, Redbubble, TeePublic, Printful, Printify) who need vector versions of designs or
  logos for embroidery, screen print, DTF or resizing
- Laser-cutting and CNC users who need DXF
- Agencies and automations (n8n, Make, Zapier, AI agents) that vectorize logos at scale through the API

Only vectorize images you own or have the rights to use.

### How to use

1. Paste **image URLs**, upload one image, or pick a **key-value store** with many images.
2. Choose **Full colour** or **Single colour cut file**.
3. Run, then download from the **SVG** column (and PDF/EPS/DXF if you enabled them), or from the run's key-value store.

#### Input examples

Cricut cut file from a transparent PNG, 10 inches wide, with a DXF too:

```json
{ "imageUrls": ["https://example.com/my-design.png"], "mode": "bw", "widthInches": 10, "outputDxf": true }
```

Three-colour layered vinyl from a logo JPG, with your vinyl colours:

```json
{ "imageUrls": ["https://example.com/logo.jpg"], "colorLayering": "layers",
  "palette": ["#000000", "#FFFFFF", "#D62828"] }
```

A small, blurry logo with the AI pre-pass and smooth curves:

```json
{ "imageUrls": ["https://example.com/logo-300px.png"], "aiUpscale": "auto", "curveStyle": "smooth" }
```

#### Output example (one dataset row per image)

```json
{
  "index": 1, "status": "success", "mode": "color",
  "svgUrl": "https://api.apify.com/v2/key-value-stores/…/records/0001-logo.svg",
  "pdfUrl": null, "epsUrl": null, "dxfUrl": null,
  "colors": ["#143C33", "#FFFFFF", "#DCA93C"], "colorCount": 3, "pathCount": 33, "nodeCount": 579,
  "svgSizeKB": 20.3, "widthInches": 4, "heightInches": 4, "layering": "stacked",
  "aiUpscaled": false, "backgroundRemoved": "#FFFFFF", "photoScore": 0, "isPhotoLike": false,
  "inputWidth": 1200, "inputHeight": 1200, "warnings": [], "chargedEvents": ["image-vectorized"], "error": null
}
```

### Options

| Option | What it does |
|---|---|
| Output type | Full colour, or single-colour cut file |
| Max colours / Fixed palette | Auto colour detection, a colour limit (2–64), or snap to your hex colours |
| Colour layering | Stacked shapes (smallest file), or one non-overlapping layer per colour |
| Curves | Balanced, smooth, sharp or polygon; advanced: corner angle, curve tolerance |
| Remove specks | Drops islands and holes up to N px (default 3) |
| Background | Auto, remove, or keep; colour tolerance |
| Single-colour method | Auto, silhouette, or dark ink with threshold and invert |
| Output files | SVG always; optional PDF, EPS, DXF (mm, one layer per colour) |
| Size | Width in inches or source DPI; SVG units in, mm or px |
| AI upscale | Off, auto (< 1000 px), or always (≤ 1500 px) |
| Photos | Convert with a warning, skip (free), or convert silently |

### Tips

- **Cricut Design Space:** upload the SVG, and it arrives at the size in the file (inches). A single-colour file is one layer;
  use *Attach* only if you split it. For layered vinyl, use *Colour layering → one layer per colour*.
- **Fewer nodes, faster cuts:** use curves *smooth*, raise *Remove specks* to 5–10, or lower *Max colours*.
- **White artwork on black:** single colour with *dark ink* and *invert*.
- **Thin details lost?** Lower *Remove specks* to 1, use curves *sharp*, or turn on the AI pre-pass for small images.
- **Photos:** vectorizing makes a posterized look. For photo prints, use our
  [Print-Ready Image Upscaler](https://apify.com/vncntlabs/print-ready-upscaler) instead.

### Pricing

Pay per result. You never pay for failed images.

| Event | Price |
|---|---|
| Image vectorized (SVG + any PDF/EPS/DXF) | $0.02 |
| AI upscale pre-pass (only when it runs) | +$0.03 |

1,000 logos cost $20. Set **Max cost per run** in the run options, and the run stops cleanly before going over it.

### Limits

- Input: PNG, JPG, WEBP, GIF (first frame), BMP, TIFF; up to 50 MP and 50 MB each (adjustable). SVG and PDF inputs are rejected
  because they're already vectors.
- Very large images are traced at up to 3000 px on the long side, which is plenty for vector output. Photos are traced at
  1600 px.
- The default memory is 2 GB. A typical design takes about 8 s (2 GB gets twice the CPU of 1 GB, and you pay per image, not per second).

### Licences and tech

- Tracing: VTracer by visioncortex (MIT), with our own palette detection, cleanup and Bezier
  fitting
- AI pre-pass: Real-ESRGAN `realesr-animevideov3` (BSD-3-Clause, Xintao Wang)
- Other libraries: Pillow (MIT-CMU), NumPy and SciPy (BSD-3), ezdxf (MIT) and ONNX Runtime (MIT)

All of them allow commercial use. The files you create are yours.

### Related Actors

- [POD & KDP Trademark Checker](https://apify.com/vncntlabs/pod-trademark-checker): screen titles and tags against 4.4M+ live US trademarks
- [Print-Ready Image Upscaler](https://apify.com/vncntlabs/print-ready-upscaler): exact print sizes for Merch, Redbubble, Etsy and KDP
- [Keyword Search Volume](https://apify.com/vncntlabs/keyword-search-volume): Google and Amazon search volume with trademark flags

Questions or a feature request? Open an issue on the Actor page.

# Actor input Schema

## `imageUrls` (type: `array`):

Direct links to PNG, JPG, WEBP, GIF (first frame), BMP or TIFF files. One vector file set per image. Use direct download links, not share/preview pages.

## `uploadedImage` (type: `string`):

Upload a single image from your computer.

## `keyValueStoreId` (type: `string`):

Pick one of your key-value stores; every key ending in .png/.jpg/.jpeg/.webp/.gif/.bmp/.tif(f) is vectorized unless you list keys below.

## `keyValueStoreKeys` (type: `array`):

Optional: only process these keys.

## `mode` (type: `string`):

Single colour makes one black compound path with clean holes - one cut layer in Cricut Design Space.

## `maxColors` (type: `integer`):

Auto finds the design's real flat colours and ignores anti-aliased edge pixels. Set e.g. 3 for a 3-colour vinyl or screen-print job.

## `palette` (type: `array`):

Optional: snap every colour to these, e.g. your vinyl colours #000000, #FFFFFF, #D62828. Overrides max colours.

## `colorLayering` (type: `string`):

Layers = one compound path per colour, grouped and named by hex code.

## `curveStyle` (type: `string`):

How outlines are fitted. Smooth gives the lightest cut files.

## `speckleSize` (type: `integer`):

Removes dust, JPEG noise and tiny islands/holes up to this size (in source pixels, squared area). 0 = keep everything.

## `background` (type: `string`):

Only background connected to the image edge is removed, so white inside the design (eyes, letters) stays.

## `backgroundTolerance` (type: `integer`):

Higher removes more near-background shades (JPEG noise).

## `bwMethod` (type: `string`):

How the single-colour cut shape is chosen.

## `bwThreshold` (type: `integer`):

Darkness cut-off for the dark-ink method. Empty = automatic (Otsu).

## `invert` (type: `boolean`):

For white artwork on a dark background.

## `outputPdf` (type: `boolean`):

Vector PDF (Illustrator, Affinity, print shops).

## `outputEps` (type: `boolean`):

Vector EPS (stock sites, older software).

## `outputDxf` (type: `boolean`):

DXF in millimetres, one layer per colour (laser cutters, LightBurn, CNC, Cricut).

## `widthInches` (type: `number`):

Physical width of the SVG/PDF/EPS/DXF. Empty = source pixels / DPI below.

## `dpi` (type: `integer`):

Used for the physical size when no width is given (300 = typical POD file).

## `svgUnits` (type: `string`):

Units for the SVG width/height attributes (the drawing is the same). Pixels are CSS pixels (96 per inch); without a width they match the source image size.

## `aiUpscale` (type: `string`):

Real-ESRGAN pre-pass for small or blurry sources: cleaner edges, fewer junk nodes. Charged only when it actually runs.

## `photoHandling` (type: `string`):

Vectorizing suits logos, text, line art and flat designs. Photos become a flat-colour poster look.

## `cornerThreshold` (type: `integer`):

Turns sharper than this stay corners. Default by curve style (40/55/60). Above ~65 thin spikes may round off.

## `curveTolerance` (type: `number`):

Max distance the curve may deviate from the traced outline. Default by curve style (0.5/0.8/1.1).

## `animatedImages` (type: `string`):

Animated files are rejected (not charged) unless you choose to use the first frame.

## `maxImages` (type: `integer`):

Safety limit; extra images are skipped.

## `maxInputFileSizeMB` (type: `integer`):

Bigger files are rejected (not charged).

## Actor input object example

```json
{
  "imageUrls": [
    "https://api.apify.com/v2/key-value-stores/8dt4uF3opznoIpk4z/records/tee-sunset-badge.png"
  ],
  "mode": "color",
  "maxColors": 0,
  "colorLayering": "stacked",
  "curveStyle": "balanced",
  "speckleSize": 3,
  "background": "auto",
  "backgroundTolerance": 40,
  "bwMethod": "auto",
  "invert": false,
  "outputPdf": false,
  "outputEps": false,
  "outputDxf": false,
  "dpi": 300,
  "svgUnits": "in",
  "aiUpscale": "off",
  "photoHandling": "warn",
  "animatedImages": "reject",
  "maxImages": 100,
  "maxInputFileSizeMB": 50
}
```

# Actor output Schema

## `results` (type: `string`):

One row per image: SVG/PDF/EPS/DXF links, colours, node count, size, warnings. Failed images show the reason and are not charged.

## `files` (type: `string`):

All generated SVG/PDF/EPS/DXF files (key-value store).

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

Succeeded/failed counts, AI pre-passes, runtime, peak memory.

# 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 = {
    "imageUrls": [
        "https://api.apify.com/v2/key-value-stores/8dt4uF3opznoIpk4z/records/tee-sunset-badge.png"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("vncntlabs/png-to-svg-vectorizer").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 = { "imageUrls": ["https://api.apify.com/v2/key-value-stores/8dt4uF3opznoIpk4z/records/tee-sunset-badge.png"] }

# Run the Actor and wait for it to finish
run = client.actor("vncntlabs/png-to-svg-vectorizer").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 '{
  "imageUrls": [
    "https://api.apify.com/v2/key-value-stores/8dt4uF3opznoIpk4z/records/tee-sunset-badge.png"
  ]
}' |
apify call vncntlabs/png-to-svg-vectorizer --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vncntlabs/png-to-svg-vectorizer"
        }
    }
}
```

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/rMZJlbvBHt3f0N89s/builds/8VuY9sXt6hDmB3Iwd/openapi.json