No. Decoding, downsampling (to a 2048 px longest-edge cap before tracing), WASM tracing, and SVG serialisation all run client-side in a module Web Worker. DevTools Network tab shows zero upload requests. Browser WebP decoding required (Chrome 32+ / Firefox 65+ / Safari 14+ since 16 September 2020 / Edge 18+).

WebP to SVG Vectoriser Online — Logo / Illustration / Photo / B&W via VTracer (Rust → WASM)

Q: Is this true vectorisation?

The Logo, Illustration, and Photo presets produce true vector paths — real elements built from cubic Bezier splines (VTracer Spline mode, stacked colour layers). The Embed preset is technically a vector file — the SVG scales via viewBox — but the content is the original WebP raster wrapped in an SVG element as a Base64 data URL; it does not generate extracted paths. Pick any traced preset for genuine vectorisation, Embed for raster-in-SVG wrapping. The tracer is VTracer (visioncortex/vtracer, Rust, MIT-licensed), compiled to WASM, running entirely in-browser.

Q: Does it handle both lossy and lossless WebP?

Yes. Both variants are decoded by the browser's native WebP decoder into raw RGBA pixels before tracing begins — the tracer sees the same pixel format regardless of whether the source was lossy VP8 (RFC 6386) or lossless VP8L (RFC 9649 §3). Lossy WebP can introduce block-boundary artefacts similar to JPEG before decode; these influence how the tracer separates colour layers, which is why the Logo preset's speckle filter is useful for lossy sources with strong compression. Lossless WebP decodes cleanly and benefits most from the Illustration or Photo preset.

Q: Will the SVG be smaller than the WebP?

Depends on the preset. Logo aggressively filters speckle and targets flat-colour sources — often smaller than the source WebP for logos and icons. Photo preserves maximum colour precision and finest layer separation; files can be much larger than the source for photographic content. Embed is always larger because Base64-encoding the raster adds ~33% overhead on top of the WebP bytes. The B&W preset produces compact single-colour paths — very small for line art.

Q: Does WebP transparency survive?

In the Embed preset, yes — the raw WebP blob (including its ALPH chunk per RFC 9649 §2.7.1.2) is Base64-encoded directly into the SVG href; alpha is preserved exactly as in the source. For the traced presets (Logo, Illustration, Photo, B&W), the tracer receives RGBA pixels from Canvas getImageData — test with your specific asset to confirm transparency handling, as behaviour depends on vtracer internals.

WebP to SVG Vectoriser — VTracer WASM, Lossy + Lossless WebP

Convert WebP images (RFC 9649 Zern, Massimino & Alakuijala — Google LLC, November 2024 Informational; lossy mode VP8 keyframes per RFC 6386 Bankoski et al. November 2011, lossless mode LZ77 + Huffman/prefix coding) to SVG (W3C SVG 1.1 Second Edition, Recommendation 16 August 2011) using VTracer (visioncortex/vtracer, Rust, MIT-licensed), compiled to WebAssembly by this project and running in a module Web Worker — your files never leave the device. Both lossy and lossless WebP variants reach the same tracing pipeline after the browser decodes them to an RGB(A) pixel array. Four intent-based presets: **Logo** (aggressive speckle cleanup, flat colors — ideal for logos and icons saved as WebP), **Illustration** (balanced color clustering, smooth curves — ideal for flat-color artwork and vector-style illustrations in WebP), **Photo** (maximum color precision, finest layer separation — a detailed vector painting from photographic WebPs; more paths, bigger file), and **B&W** (binary tracing — monochrome outline, ideal for line art or high-contrast WebP content). Tracing works on a downsampled copy (max 2048 px longest edge) and is deterministic. **Embed** mode wraps the WebP raster in an SVG `<image>` element with alpha preserved end-to-end — WebP's ALPH chunk per RFC 9649 §2.7.1.2 round-trips into the SVG `<image>` data URL. Optional Sobel edge outline adds a vector contour for cut/print workflows. Browser WebP decoding required: Chrome 32+, Firefox 65+, Safari 14+ (16 September 2020), Edge 79+ (Chromium, 15 January 2020).

How to convert WebP to SVG

Drop a .webp file onto the tool or click to browse. The browser decodes the WebP (lossy via VP8 per RFC 6386 or lossless via LZ77 + Huffman per RFC 9649 §3) to an RGB(A) pixel array.
Choose a preset: Logo (flat colors, speckle cleanup), Illustration (balanced), Photo (max detail — more paths, bigger file), B&W (binary monochrome outline), or Embed (original raster in SVG wrapper, alpha preserved via WebP's ALPH chunk).
Adjust advanced sliders if needed: Colors (color precision 1–8), Smoothness (corner threshold), Detail (speckle filter). Re-tracing happens automatically.
For Embed mode, optionally enable the Sobel edge outline for a vector contour suitable for cut/print workflows.
Download the SVG. The original WebP stays on disk untouched — files never leave the device.

Common use cases

Vectorising flat-colour WebP logos or icons (Logo preset) for laser cutters, vinyl plotters, or vector editors.
Producing the most detailed SVG from a photographic WebP (Photo preset) for a design-system slot that must be SVG.
Embedding a transparent WebP inside an SVG-only environment via Embed mode — the ALPH chunk alpha round-trips byte-exactly into the SVG `<image>`.
Generating sticker / decal artwork from a WebP photo: Embed mode raster + Sobel edge outline drives a cutter while the raster shows the design.
Migrating a WebP-first asset pipeline back to SVG when stakeholder requirements demand vector editor compatibility (Logo or Illustration preset).

Frequently asked questions

Is this true vectorisation?

For the four tracing presets (Logo, Illustration, Photo, B&W) yes — the SVG contains real `<path>` elements with cubic Bezier spline data that scale losslessly. Embed mode produces a technically valid SVG but the content is the original WebP raster inside an `<image>` element with alpha preserved via WebP's ALPH chunk.

Does it handle both lossy and lossless WebP?

Yes. Both variants reach VTracer after the browser decodes them to an RGB(A) pixel array — the tracing pipeline is the same regardless of whether the source used VP8 lossy (RFC 6386) or LZ77 + Huffman lossless (RFC 9649 §3).

Will the SVG be smaller than the WebP?

Depends on preset. Logo and B&W SVGs are typically smaller than the source WebP for flat-color content. Photo SVG can be larger than the WebP for photographic content because path data grows with color precision. Embed SVG is larger because Base64 encoding adds ~33% overhead.

Does WebP transparency survive?

In Embed mode, yes — WebP's ALPH chunk (alpha plane per RFC 9649 §2.7.1.2) round-trips byte-exactly into the SVG `<image>` element data URL. In the tracing presets, transparent areas (pixels below the alpha threshold) are excluded from tracing.

Is my file uploaded?

No. VTracer runs as a WASM module inside a Web Worker in your browser — no server round-trips. Browser WebP decoding required (Chrome 32+ / Firefox 65+ / Safari 14+ since 16 September 2020 / Edge 79+).

WebP-to-SVG trade-offs: VTracer presets vs Embed mode, lossy vs lossless

WebP → SVG handles two distinct WebP variants: lossy WebP (VP8 keyframe encoding per RFC 6386, with quantisation artefacts similar to JPG's 8×8 DCT but using a different prediction model) and lossless WebP (LZ77 + Huffman/prefix coding per RFC 9649 §3, with no quantisation but potentially anti-aliased edges). Both variants reach VTracer after the browser decodes them to an RGB(A) pixel array. The presets pick different trade-offs: **Logo** applies aggressive speckle filtering (Detail slider) and flat-color clustering — suited to WebP logos and icons where discrete color regions dominate. **Illustration** balances color precision (Colors slider, 1–8 levels) and curve smoothness (Smoothness slider, corner threshold) — suited to vector-style artwork and flat-color graphics in lossy or lossless WebP. **Photo** maximises color precision and layer separation, producing the most detailed vector output for photographic WebP — more paths and a bigger file than Logo or Illustration. **B&W** applies binary tracing — the WebP is thresholded to two values before VTracer runs, producing a monochrome outline SVG. **Embed** mode wraps the original WebP raster (with alpha intact via WebP's ALPH chunk per RFC 9649 §2.7.1.2) inside an SVG `<image>` element; the file IS valid SVG and scales via viewBox, but content remains pixel-bound. Optional Sobel edge overlay (3×3 isotropic gradient operator, Sobel & Feldman 1968 Stanford SAIL) adds a vector outline for sticker / vinyl-cut workflows. VTracer uses cubic Bezier splines and a stacked layering strategy; output is deterministic: same WebP, same preset, same sliders → same SVG every time.

VTracer WASM engine (visioncortex/vtracer, Rust, MIT) — self-built, vendored ~122 KB, module Web Worker
Four tracing presets: Logo, Illustration, Photo (max detail — more paths, bigger file), B&W (binary outline)
Source decoding: lossy WebP (VP8 per RFC 6386) + lossless WebP (LZ77 + Huffman per RFC 9649 §3)
WebP alpha preserved in Embed mode — ALPH chunk per RFC 9649 §2.7.1.2 round-trips byte-exactly
Deterministic output: same WebP + preset + sliders = same SVG every time
2048 px downsampling before trace — handles high-resolution WebP sources
Output SVG per W3C SVG 1.1 Second Edition (16 August 2011) — cubic Bezier splines
Browser-side via Web Worker — files never leave the device (Chrome 32+ / Firefox 65+ / Safari 14+ / Edge 79+)

Free. No signup. No file uploads. Ads via AdSense (consent required).

Sources (7)

VisionCortex contributors (2025). VTracer — raster to vector graphics converter. github.com/visioncortex/vtracer (Rust crate vtracer 0.6, MIT OR Apache-2.0) — the tracing engine behind the Logo / Illustration / Photo / B&W presets; compiled to WebAssembly by this project (vendored build, runs in a module Web Worker), performs colour clustering and cubic Bezier spline fitting (Spline mode) with stacked layering.
Bostock, M. (D3.js) (2024). d3-contour — compute contour polygons using marching squares. github.com/d3/d3-contour (ISC license, npm v4.0.2) — contour extraction used ONLY for the optional Sobel edge outline in the Embed preset; the main tracing presets run on VTracer instead.
Sobel, I., & Feldman, G. M. (1968). A 3×3 Isotropic Gradient Operator for Image Processing. Stanford Artificial Intelligence Laboratory (SAIL) talk, 1968 (unpublished; documented in subsequent SAIL technical reports) — gradient operator for the optional edge outline in the Embed preset; produces an edge mask thresholded into a binary contour set traced by d3-contour.
Zern, J., Massimino, P., & Alakuijala, J. (Google LLC) (2024). WebP Image Format. RFC 9649, IETF (November 2024, Informational) — source WebP container; lossy mode (VP8 keyframes) and lossless mode (LZ77 + Huffman/prefix coding) both decoded to RGB(A) pixels via the browser's built-in WebP decoder (Chrome 32+, Firefox 65+, Safari 14+ since 16 September 2020) before tracing.
Bankoski, J., Koleszar, J., Quillio, L., Salonen, J., Wilkins, P., & Xu, Y. (Google Inc.) (2011). VP8 Data Format and Decoding Guide. RFC 6386, IETF (November 2011, Informational) — VP8 keyframe bitstream used by WebP lossy mode; intra-prediction blocks decoded by the browser before pixel sampling.
W3C (SVG Working Group) (2011). Scalable Vector Graphics (SVG) 1.1 (Second Edition). W3C Recommendation 16 August 2011 (w3.org/TR/SVG11/) — target SVG container format; <path d='M…'> elements carry the traced polygons, <image> element carries the embedded raster in the Embed preset.
WHATWG (live). HTML Living Standard — Canvas 2D Context: getImageData(). html.spec.whatwg.org/#dom-context-2d-getimagedata + canvas section 4.12.5 — browser-side raster sampling mechanism: decode WebP into a canvas → getImageData returns the pixel array transferred to the vectorize worker for tracing.

These are the W3C, ISO/IEC, ITU-T, and IETF specifications the tool implements or builds on. Locate them on w3.org, iso.org, itu.int, or datatracker.ietf.org.

Related guides

SVG Optimization — A Complete Guide for Web PerformanceA practical SVG optimization guide: SVGO, path simplification, viewBox handling, CSS vs inline, and the mistakes that bloat SVGs to 10× their real size.