---
title: "Vectorize Developer Portal: Free Logo to SVG API"
description: "Free, anonymous REST API and hosted MCP server that turn PNG, JPG and WebP logos into clean SVG. Quickstart with curl, sandbox endpoint, endpoint reference, limits and error format."
canonical: "https://vectorize-logo.com/developers/"
last_updated: "2026-10-15"
markdown_url: "https://vectorize-logo.com/developers.md"
---

# Vectorize Developer Portal

HTML version: https://vectorize-logo.com/developers/ · Markdown: https://vectorize-logo.com/developers.md · Site index for agents: https://vectorize-logo.com/llms.txt

> Free, anonymous REST API and hosted MCP server that turn PNG, JPG and WebP logos into clean SVG. Quickstart with curl, sandbox endpoint, endpoint reference, limits and error format.

REST API · Hosted MCP · Free

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

## Overview

### Base URL

```
https://vectorize-logo.com
```

### OpenAPI specification

```
https://vectorize-logo.com/openapi.json
```

### Hosted MCP server

```
https://vectorize-logo.com/api/mcp/
```

## 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](https://vectorize-logo.com/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`.

### Set the base URL

```bash
BASE=https://vectorize-logo.com
```

### Try the sandbox

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

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

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

### 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.

```bash
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.

### Download the SVG

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

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

### Refine the result

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

```bash
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)
```

### 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.

```bash
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)
```

### 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.

```bash
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.

Interactive form: POST /api/sample (fields: trim). Use the API directly instead.

Interactive form: POST /api/vectorize (fields: file, colors, smoothing, transparent, trim). Use the API directly instead.

## Endpoint reference

Full schemas, parameters and response types are in the [OpenAPI specification](https://vectorize-logo.com/openapi.json).

| 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:

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

```http
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
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](https://vectorize-logo.com/api) and the OpenAPI document.

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

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

{"status":"ok"}
```

```bash
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-logo.com/developers/#versioning>; rel="deprecation"
```

## MCP server for agents

Agents can use the same engine through `https://vectorize-logo.com/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](https://vectorize-logo.com/mcp/).

Use of the API is covered by the [Terms](https://vectorize-logo.com/terms/). Uploaded images are handled as described in the [Privacy Policy](https://vectorize-logo.com/privacy/).