REST API · Hosted MCP · Free

Vectorize Developer Portal

Convert PNG, JPG and WebP logos into clean SVG from your own code or from an AI agent. The REST API and the hosted MCP server are free and need no account, API key or SDK.

No API key Sandbox endpoint OpenAPI 3 spec

Authentication and API keys

There are none: every request is anonymous.

Vectorize does not issue API keys, tokens or accounts. Send requests directly; no Authorization header is needed. A job token returned by the API is an unguessable identifier for one temporary result. Anyone who holds it can read that job until it expires, so treat it like a private link.

The service is shared and runs one job at a time. Please use it fairly: do not run bulk conversions or load tests against it. If you need guaranteed capacity, contact support. If keys or quotas are ever added, this page will say so.

Quickstart

From a logo file to an SVG and a brand kit with curl and jq.

0 Set the base URL

BASE=https://vectorize.stemonte.io

1 Try the sandbox

Create a demo job without uploading anything. The response contains a job token that works with every /api/jobs/{token}/… endpoint.

curl -s -X POST "$BASE/api/sample" | tee job.json
TOKEN=$(jq -r .id job.json)

{
  "id": "ef9709ad95ed45cb8681da6b21dbbeab",
  "svg": "/api/jobs/ef9709ad95ed45cb8681da6b21dbbeab/logo.svg",
  "palette": ["#01643b", "#e9f3ef"],
  "bytes": 153180,
  "width": 508,
  "height": 515
}

2 Upload your logo

Send a PNG, JPG or WebP as multipart/form-data. colors is 0 (automatic) or 1, 2, 3, 4, 6 or 8; smoothing is 0–100; transparent and trim are true or false. Every field except file is optional.

curl -s -X POST "$BASE/api/vectorize" \
  -F file=@logo.png \
  -F colors=4 \
  -F smoothing=20 \
  -F transparent=true \
  -F trim=true | tee job.json
TOKEN=$(jq -r .id job.json)

The response has the same shape as the sandbox response, plus a warning string that describes automatic changes such as background removal.

3 Download the SVG

The svg field of the response is a relative URL. Add ?download=true to get a Content-Disposition: attachment response.

curl -s "$BASE/api/jobs/$TOKEN/logo.svg" -o logo.svg

4 Refine the result

Upload the same file again with different settings. Each upload creates an independent job with its own token.

curl -s -X POST "$BASE/api/vectorize" \
  -F file=@logo.png \
  -F colors=2 \
  -F smoothing=60 | tee job.json
TOKEN=$(jq -r .id job.json)

5 Hide colors

Create a new job with some palette colors hidden, without re-tracing. At least one color must stay visible. This example hides the second palette color; use the returned id from here on.

jq -c '{hidden_colors: [.palette[1]]}' job.json |
  curl -s -X POST "$BASE/api/jobs/$TOKEN/visibility" \
    -H "Content-Type: application/json" \
    -d @- | tee hidden.json
TOKEN=$(jq -r .id hidden.json)

6 Export the brand kit

Build a ZIP with SVG and PNG logo variants, a brand guide and palette, web favicons and icons, native app icons, social images and cap and T-shirt mockups. name is up to 80 characters; background_color is a six-digit hex.

curl -s -X POST "$BASE/api/jobs/$TOKEN/kit" \
  -H "Content-Type: application/json" \
  -d '{"name": "Acme", "background_color": "#ffffff"}' \
  -o brand-kit.zip

Sandbox (test environment)

POST /api/sample is the sandbox.

The sandbox returns a demo job built from a bundled sample logo. You upload nothing, so no image of yours is involved. Use it to test your integration end to end: read the response, download the SVG, hide colors, request a preview or build a kit. Sandbox jobs behave like real jobs and are deleted after two hours. The sandbox runs on the same server as the live API; there is no separate test host.

Browser agents do not need curl: this site registers WebMCP tools (create_sample_vectorization, vectorize_logo, get_svg, hide_colors, download_brand_kit and get_developer_resources) on document.modelContext, and the forms below are declared as WebMCP tools too.

Try the API

Plain HTML forms that call the live endpoints. The JSON result opens in a new tab.

Endpoint reference

Full schemas, parameters and response types are in the OpenAPI specification.

Method	Path	Purpose
`POST`	`/api/vectorize`	Upload a PNG, JPG or WebP (multipart field file) and create a job.
`POST`	`/api/sample`	Sandbox: create a demo job without uploading an image.
`GET`	`/api/jobs/{token}/logo.svg`	Download the SVG of a job.
`GET`	`/api/jobs/{token}/preview.png`	Download a PNG preview.
`POST`	`/api/jobs/{token}/visibility`	Create a new job with listed palette colors hidden.
`POST`	`/api/jobs/{token}/kit`	Build the brand kit and return it as a ZIP.
`GET`	`/api/jobs/{token}/brand-kit.zip`	Download a kit exported through the MCP export_brand_kit tool.
`GET`	`/api/jobs/{token}/mockup/{kind}.png`	Render a cap or tshirt mockup.
`POST`	`/api/jobs/{token}/editor/settings`	Re-trace an MCP-created revision with new settings.
`POST`	`/api/jobs/{token}/editor/visibility`	Hide colors on an MCP-created revision.
`GET`	`/api`	JSON index: links, limits and main endpoints.
`GET`	`/api/health`	Health check.

The editor/… endpoints only accept revisions created through the hosted MCP server. For jobs created with POST /api/vectorize, upload again with new settings and use /visibility to hide colors.

Limits and errors

Plan for temporary jobs and one job at a time.

Input: PNG, JPG or WebP, up to 10 MB, 8 to 6000 pixels per side and up to 20 megapixels. Larger files get 413; other unusable images get 422.
429 busy: One job is processed at a time. If another is running you get 429; wait a moment and retry.
422 validation: Invalid field values or an image that cannot be traced. Form and body validation errors list the problems; other 422 responses carry a message.
404 not found: A job token that is unknown or older than two hours, or an unknown /api/… path.
Lifetime: Jobs and their files are deleted two hours after they are created. Download what you need before then.

Errors are JSON with a detail field, which is a string or, for validation errors, a list of objects:

curl -s -i "$BASE/api/jobs/00000000000000000000000000000000/logo.svg"

HTTP/2 404
content-type: application/json

{"detail":"This logo has expired. Upload it again."}

Idempotency

Retry a write safely with an Idempotency-Key header.

Send an optional Idempotency-Key (1 to 255 printable ASCII characters, for example a random UUID) on POST /api/vectorize, POST /api/sample, POST /api/jobs/{token}/visibility, POST /api/jobs/{token}/editor/settings, POST /api/jobs/{token}/editor/visibility and POST /api/mcp/uploads. If a network error or a 429 hides the outcome, repeat the request with the same key instead of risking a second job.

KEY=$(uuidgen)
curl -si -X POST "$BASE/api/sample" -H "Idempotency-Key: $KEY"
curl -si -X POST "$BASE/api/sample" -H "Idempotency-Key: $KEY"

HTTP/2 200
content-type: application/json
vectorize-version: 2026-10-14

{"id":"ef9709ad95ed45cb8681da6b21dbbeab", ...}

HTTP/2 200
content-type: application/json
idempotent-replayed: true
vectorize-version: 2026-10-14

{"id":"ef9709ad95ed45cb8681da6b21dbbeab", ...}

Replay: The same key with the same parameters returns the first successful response with Idempotent-Replayed: true. Nothing is processed again. For uploads, the parameters are the file content and the form fields, not the multipart boundary.
422 different parameters: The same key with other parameters is rejected. Use a new key for a different request.
409 in progress: The first request with that key is still running. Wait for Retry-After seconds and retry with the same key.
400 invalid key: The key is empty, longer than 255 characters or not ASCII.
Errors and expiry: Only successful responses are stored, so retrying after 429, 413 or 422 runs the request again. Keys expire after two hours, together with the job, and a key is not replayed once its job is gone.
POST /api/jobs/{token}/kit: Naturally idempotent: it changes nothing, so repeating it returns an equivalent archive. The header is accepted and validated there, but nothing is stored.

Versioning and deprecation

Date-based versions in the Vectorize-Version header. Current version: 2026-10-14.

Paths are not versioned. Send the optional Vectorize-Version request header to pin a version; leave it out to get the current one. An unknown version returns 400 with the supported versions in detail. Every /api response, including errors, carries a Vectorize-Version header with the version that answered. The same information is in the API index and the OpenAPI document.

curl -si "$BASE/api/health" -H "Vectorize-Version: 2026-10-14"

HTTP/2 200
content-type: application/json
vectorize-version: 2026-10-14

{"status":"ok"}

curl -s "$BASE/api/health" -H "Vectorize-Version: 1999-01-01"
{"detail":"Unsupported Vectorize-Version '1999-01-01'. Supported versions: 2026-10-14."}

Breaking changes: They ship only under a new dated version. Existing versions keep their behavior until they are removed.
Deprecation signals: A deprecated version or endpoint answers with Deprecation (RFC 9745), Sunset (RFC 8594) and a Link header with rel="deprecation" that points to this section.
Timeline: The signals start, and the change is announced on this page, at least 90 days before anything is removed. Nothing is deprecated today.

Example of the headers on a deprecated endpoint (illustrative):

deprecation: @1799971200
sunset: Thu, 15 Apr 2027 00:00:00 GMT
link: <https://vectorize.stemonte.io/developers/#versioning>; rel="deprecation"

MCP server for agents

Agents can use the same engine through https://vectorize.stemonte.io/api/mcp/.

The hosted MCP server exposes tools to create, inspect, refine and export a vectorization, with a review step before the brand kit. Setup for Codex and Claude Code is on the MCP page.

Use of the API is covered by the Terms. Uploaded images are handled as described in the Privacy Policy.