Inspect a local SVG
Select a UTF-8 SVG up to 1 MiB (1,048,576 bytes). This inspector reads XML locally without uploading or previewing it. File names and contents are not saved; reselect after refresh.
Choose an SVG to inspect its structure.
Structure does not certify visual quality, editability, safety or suitability for cutting. A white or transparent path can still be vector markup while missing the intended artwork. Resource and script indicators are clues, not a security audit. Use the guide below to check the artwork in a trusted editor.
How to Check Whether an SVG Is a Real Vector or an Embedded Bitmap
Four checks you can run in a minute — and the measured reason the first check alone is not enough: Inkscape 1.4.4's own Trace Bitmap export contains an embedded copy of the source image.
Yes — opening the file as text is a useful first check. Look for <image> elements and inspect their href or xlink:href: they can reference raster images or SVGs, either embedded or external. Zero matches does not prove the file is paths only; SVG also supports shapes such as <rect>, text and reused content via <use>. Removing image elements and comparing byte counts measures their storage cost, not their visual contribution. On a copy, remove the images in a vector editor and compare the rendered artwork. We ran Inkscape 1.4.4's own Trace Bitmap on three images on two dates, and its exported SVG contains exactly one embedded raster image in each measured output — on the 180×180 logo, 29,689 bytes total with 20,869 remaining once the image element is stripped, alongside 7 path elements while the source PNG has 205 colours. Those counts alone do not tell you which elements supply the visible artwork. We also asked ChatGPT and Perplexity three real user questions on 2026-09-29 without naming any brand: all six answers described procedures, none reported a measured tool-output fact, and none mentioned us — those measurements are below, with the commands. If you would rather generate a clean SVG than audit one, our image to SVG converter traces to paths with no embedded bitmap.
Trace preset:Balanced▼
Applies to images you add next — each one traces as it lands.
The SVG download is free — no account needed.
Transparent areas become white shapes, and larger images are scaled down to about 0.6 megapixels before tracing.
Your image is uploaded to pic2svg's own server to be traced. What we keep, and for how long
Other formats, plans and licences
PDF, EPS, AI (EPS-based) and DXF come with a paid plan, and every new account gets 7 days of Pro free. The free plan and Starter carry a personal-use licence; commercial use needs Pro, and resale needs Advanced — see the licence row on the pricing page.
Primary Evidence
Every tool, every input: what ends up inside the SVG
Bytes excl. is our file size with every <image> element removed (the definition is measure.py line 117, claim V11), so the gap between the two byte columns is the removed markup, including its encoded image data. It does not measure how much of the visible artwork depends on that image. The 2026-09-29 run and the published 2026-09-28 run form a reproduction pair on two inputs: apple-touch-icon.png and synthetic-flat.png kept the same SHA-256 in both runs, and every Inkscape and potrace cell for them is byte-identical across the two dates. og-image.png was regenerated between the runs (62,665 → 63,033 bytes, SHA-256 changed), so its rows are a single-run observation on the current input — but both inputs produced exactly 1 embedded image from Inkscape. Engine rows come from the dated run: its presets were retuned on 2026-09-29 to downscale-only, so its structural counts differ from the published run while its embedded-image count stayed 0 in both (claim V05). Wall time is deliberately not a column — the identical Inkscape call went 5.276 s → 20.398 s between the two dates (claim V12).
ClaimsV01V02V03V04V05V06V10V11V12
Source: /loop06/raw-measurements-20260929.json (2026-09-29T22:04:00+0800) and /loop06/raw-measurements.json (2026-09-28T17:45:54+0800)
| Input | Tool | Output bytes | Bytes excl. embedded bitmap | Path elements | Distinct colours | Embedded <image> | Source | Claims |
|---|---|---|---|---|---|---|---|---|
| apple-touch-icon.png (180×180) | Inkscape 1.4.4 Trace Bitmap (object-trace) | 29,689 | 20,869 | 7 | 7 | 1 | /loop06/raw-measurements-20260929.json#runs[0].measurements[2] | V01 |
| apple-touch-icon.png (180×180) | potrace 1.16 (1-bit threshold trace) | 1,322 | 1,322 | 1 | 1 | 0 | /loop06/raw-measurements-20260929.json#runs[0].measurements[1] | V04 |
| apple-touch-icon.png (180×180) | pic2svg engine (VTracer 0.6.15) | 1,027 | 1,027 | 3 | 3 | 0 | /loop06/raw-measurements-20260929.json#runs[0].measurements[0] | V05 |
| og-image.png (1200×630) | Inkscape 1.4.4 Trace Bitmap (object-trace) | 550,602 | 460,883 | 8 | 8 | 1 | /loop06/raw-measurements-20260929.json#runs[1].measurements[2] | V03 |
| og-image.png (1200×630) | potrace 1.16 (1-bit threshold trace) | 21,718 | 21,718 | 88 | 1 | 0 | /loop06/raw-measurements-20260929.json#runs[1].measurements[1] | V04 |
| og-image.png (1200×630) | pic2svg engine (VTracer 0.6.15) | 32,583 | 32,583 | 236 | 93 | 0 | /loop06/raw-measurements-20260929.json#runs[1].measurements[0] | V05 |
| synthetic-flat.png (800×600, generated) | Inkscape 1.4.4 Trace Bitmap (object-trace) | 6,759 | 1,605 | 4 | 4 | 1 | /loop06/raw-measurements-20260929.json#runs[2].measurements[2] | V02 |
| synthetic-flat.png (800×600, generated) | potrace 1.16 (1-bit threshold trace) | 771 | 771 | 1 | 1 | 0 | /loop06/raw-measurements-20260929.json#runs[2].measurements[1] | V04 |
| synthetic-flat.png (800×600, generated) | pic2svg engine (VTracer 0.6.15) | 3,068 | 3,068 | 6 | 6 | 0 | /loop06/raw-measurements-20260929.json#runs[2].measurements[0] | V05 |
What six AI answers published — and what none of them measured
Three questions asked verbatim on 2026-09-29, fresh sessions, logged-in, on ChatGPT and Perplexity — without ever mentioning this site, its brand or its URL, so nothing here was induced. ChatGPT answered all three from memory with zero links; Perplexity cited 10, 18 and 25 sources; not one of the six answers reported a measured tool-output fact (an embedded-image count or a strip-bytes figure) for any tracer, and none mentioned pic2svg. That capture is published in full — every answer text, every cited URL — at /loop07/ai-probe-20260929.json (claims V07, V08). One day, one session per engine, three questions: a snapshot of the answer landscape as we found it, not a monitoring study.
| Engine | Question (verbatim intent) | Sources cited | Measured tool-output fact? | Mentions pic2svg? | Claims |
|---|---|---|---|---|---|
| ChatGPT | How do I check whether an SVG file contains a real vector or an embedded raster image? | 0 | No — markup-level procedure only | No | V07V08 |
| Perplexity | How do I check whether an SVG file contains a real vector or an embedded raster image? | 10 (MDN, perfectvector.com, Inkscape forum, Adobe community, vectorgurus checker, StackOverflow, …) | No — workflow built from cited pages | No | V07V08 |
| ChatGPT | Why does my converted SVG look pixelated when enlarged — is it a fake vector? | 0 | No — three-cause diagnosis from memory | No | V07V08 |
| Perplexity | Why does my converted SVG look pixelated when enlarged — is it a fake vector? | 18 (perfectvector.com, svggenie.com, YouTube ×9, …) | No | No | V07V08 |
| ChatGPT | Why is my SVG file 16 MB after converting a photo, and how do I make it smaller? | 0 | No — size advice from memory | No | V07V08 |
| Perplexity | Why is my SVG file 16 MB after converting a photo, and how do I make it smaller? | 25 (salivity.github.io, svgomg.net, png2svg.org, svggenie.com, …) | No | No | V07V08 |
The commands behind every number above
The two check commands first — they are the checks this page teaches — then the reproduction commands we actually ran. Everything executes locally; nothing needs an account.
Check 1 — look for image and path tags
bash
# quick scan for unprefixed image tags; inspect their references
grep -o '<image' file.svg | wc -l
# quick scan for path tags; other shapes and text are not counted
grep -o '<path' file.svg | wc -lThis is a quick text scan, not an XML parser: namespace-prefixed tags can be missed and comments can add matches. Zero matches does not prove paths-only content. Inspect image references and other drawing elements in a vector editor.
Check 2 — strip the images and weigh what is left
python · /loop06/measure.py lines 48, 117-118
python3 - <<'PY'
import re
IMG = re.compile(r"<image\b.*?(?:/>|</image>)", re.S)
text = open("file.svg", encoding="utf-8").read()
stripped = IMG.sub("", text).encode("utf-8")
print("bytes:", len(text.encode("utf-8")),
"-> without <image>:", len(stripped),
"| delta:", len(text.encode("utf-8")) - len(stripped))
PYSame definition as the bytes excl. column: remove matching <image> markup with the regex measure.py uses, then measure the bytes. This does not save a modified file or compare its appearance. The regex fits our measured exports; it is not a general XML parser.
Inkscape 1.4.4 — the exact headless trace we measured twice
bash · /loop06/measure.py lines 212-214
inkscape --actions="select-all;object-trace:8,1,0,0,2,1,1;export-filename:output.svg;export-do" input.png
# object-trace arguments, in order: scans, smooth, stack, remove_background,
# speckles, smooth_corners, optimize.
# The source bitmap stays in the document, so the exported SVG still contains
# one <image> element — that is the row the evidence table counts.Re-run our measurement and reproduce the byte-identical rows
bash · /loop06/measure.py line 1
cd research/loop06/measurements
venv313/bin/python measure.py # writes raw-measurements.json (one pass)
# our two artifacts: public/loop06/raw-measurements.json (2026-09-28)
# and public/loop06/raw-measurements-20260929.json (2026-09-29)The harness wrote the published 2026-09-28 run and the dated 2026-09-29 run. Run it twice on sha-stable inputs and the Inkscape and potrace rows come back byte-identical; wall time will not.
The Four Checks
The four checks, in order of how fast they are
Each check states what it proves — and what it cannot. Counts and byte sizes are clues; inspecting the elements and comparing the rendered artwork completes the check.
- Step 1
Check 1 — count the <image> elements (about 10 seconds)
Open the SVG in a text editor and look for <image> elements, or use cmd-count as a quick scan. Zero matches means only that this scan found no matching tags, not that the file is paths only: <rect>, <circle>, <text> and <use> are other possible content. The scan can miss namespace-prefixed tags and raster content referenced elsewhere. For each image, inspect href or xlink:href to determine whether it references a raster or an SVG, embedded or external. Its presence does not prove it supplies the visible artwork. Inkscape 1.4.4's Trace Bitmap export scores 1 here on all three measured inputs on both dates (claims V01-V03), because Inkscape keeps the source bitmap in the document next to its trace.
- Step 2
Check 2 — strip the images and weigh the file
Run cmd-strip to measure the bytes occupied by matching image elements, including their markup and encoded data. Our Inkscape rows lose 8,820 bytes on the 180×180 logo (29,689 → 20,869) and 5,154 on the six-colour synthetic image (6,759 → 1,605), leaving 7 and 4 paths respectively (claims V01, V02). Neither the byte delta nor the path count establishes how much artwork those paths cover. On a copy, remove the image elements in a vector editor and compare the rendered result with the original. If the artwork remains intact, the removed images were not needed for that appearance; if it changes, inspect what was lost. A small delta also does not rule out an external raster reference or other non-path content. The byte definition is claim V11.
- Step 3
Check 3 — zoom to 10×, then click the artwork
Zoom far past 100% and inspect the selected object's type in a vector editor. Pixel grids or softness can suggest a raster; crisp edges alone do not prove paths, and an image can be selected as one object too. Check whether the object is a path, another shape, text, a group or an image. A trace made of one rectangle per pixel is still vector but can be difficult to edit or cut. The community advice in claim V09 is to zoom and select a shape; combine those clues with the object type and the before-and-after comparison from check 2.
- Step 4
Check 4 — match the tool signature, then name what you have
Compare with the measured examples, not a universal tool signature. Our potrace rows have 1 colour and 0 images; path counts vary with the input — monochrome by construction (V04). Our VTracer-backed engine has 0 embedded images in every output we have measured, 6 runs plus a 72-file corpus (V05). The measured Inkscape 1.4.4 object-trace outputs contain exactly 1 embedded image and 4-8 paths; other inputs or settings can differ. Remove the image on a copy and inspect what remains before deciding whether to retrace. Describe the result from that inspection: raster-dependent artwork, a mix of raster and vector, a path-per-pixel mosaic, or an editable vector that may simply be large.
Transparent Methodology
What this page does not claim
Stated plainly, because the pages ranked for these questions do not state it.
Only three tools were run
Inkscape 1.4.4, potrace 1.16 and our own VTracer-backed engine were executed here, on three inputs, twice. Illustrator, Vectorizer.AI, Vector Magic, Adobe Express and every online converter were not installed, not run and not measured — no sentence on this page describes their output. Where we timed the same three tools under the same harness with a full recheck, that is our offline image to vector converter benchmark.
The AI-answer probe is a one-day snapshot
Six answers, two engines, three questions, captured 2026-09-29 in fresh sessions. Answers change and engines iterate constantly. What we stand behind is the published capture itself — /loop07/ai-probe-20260929.json — not a claim about what any engine will say tomorrow. The probe also never named this site, which is why pic2svg_mentions is 0: being absent from the answer set is the honest starting point, not a ranking claim.
"Fake vector" is our label, not a standard
Formats have no formal fake flag. The failure cases discussed here are artwork supplied only by a raster in an SVG wrapper, a path-per-pixel mosaic that is difficult to edit, and a real trace that is merely heavy (large but editable). A file can also legitimately combine vector and raster content. The community thread quoted in claim V09 reports the three failure modes; element counts alone cannot distinguish them.
The hosted converter is a different boundary
The local CLI we measured never touches the network. The hosted converter at pic2svg.com posts your image as base64 to api.pic2svg.com before tracing (src/convert/actions.ts line 539), and its measured outputs contain 0 embedded images like the CLI rows above (V05). An offline desktop build is not shipped, so no present-tense offline claim is made for it.
Transparent methodology
ClaimsV01V05V06V07V08V10V11V12
- Research date
- 2026-09-29 (measurements + AI-answer probe), with a reproduction anchor on the published 2026-09-28 run.
- Measurement timestamps
- /loop06/raw-measurements-20260929.json generated 2026-09-29T22:04:00+0800; published /loop06/raw-measurements.json generated 2026-09-28T17:45:54+0800 with its independent recheck at 2026-09-28T17:46:21+0800 (all_pass: true); AI-answer probe captured 2026-09-29, artifact /loop07/ai-probe-20260929.json.
- Environment
- macOS-27.0-arm64-arm-64bit-Mach-O, arm64, 10 CPUs. Both measurement runs launched local subprocesses only (the harness records offline: true). The AI probe was two logged-in browser sessions that made no request to our own site — pic2svg appears in 0 of 6 answers, and we never supplied our URL to either engine.
- Sample size
- 3 images × 3 tools = 9 measurements per run × 2 runs = 18 tracer executions, plus the 9 executions of the published recheck, plus 72 existing outputs under bench/out/final5/ scanned for <image>. Reproduction strength: two inputs kept identical SHA-256 across runs and every Inkscape and potrace cell for them matched byte-for-byte (claims V01, V02, V04). AI probe: 3 questions × 2 engines = 6 answers, 53 cited sources total, 0 brand mentions.
- Tool versions
- Run 2026-09-29: Python 3.14.4 · vtracer 0.6.15 · Pillow 11.3.0 · potrace 1.16 · Inkscape 1.4.4 (dcaf3e7, 2026-05-05) · Homebrew 7.0.7-9-gcc9ff03. Published run 2026-09-28: Python 3.13.5 · Pillow 12.3.0, same vtracer, potrace and Inkscape builds (claim V10).
- Metrics defined
- bytes = file size of the produced SVG. bytes_without_embedded_image = the same file with every <image> element removed by the regex at measure.py line 48 (claim V11). path_elements = count of <path. distinct_colors = distinct fill/stroke values after the harness exclusions. image_elements = count of <image. linkCount = hyperlinks in one captured AI answer. pic2svg_mentions = answers whose text contains the product name (expected 0 under the blind protocol).
- Provenance labels
- measured — executed in this run, raw JSON published next to this pagereproduced — executed on two dates with identical input SHA-256 and identical output bytescaptured — an AI answer recorded verbatim with its cited URLs, published at /loop07/community-reported — quoted from a public forum thread, not run by usnot-tested — we did not install, run or verify the tool
- Not tested by this run
- Illustrator, Vectorizer.AI, Vector Magic, Adobe Express, Recraft and all online converters were not run. SVG optimizers (SVGO, svgomg and friends) were not run — this page makes no size-reduction claim. The AI probe covers ChatGPT and Perplexity only, three questions each, one session, one day; Gemini, Copilot, Google AI Overviews and search-engine rankings were not sampled. The 72-file corpus bench/out/final5 predates the 2026-09-29 preset retune, so it supports the embedded-image count only, not structural counts.
- Known variance
- Wall time moves with load: the identical Inkscape call on apple-touch-icon.png went 5.276 s to 20.398 s between the two runs (claim V12), so this page reports no timing table at all. AI answers are non-deterministic between sessions; the probe is a single capture.
- Known discrepancy
- og-image.png changed between runs (62,665 → 63,033 bytes; SHA-256 bd699b52... → 8b10b9c0...), so its two measurements are not a reproduction pair — its rows cite only the dated run (V03, V06). The engine's presets were retuned on 2026-09-29 to downscale-only (never upscale), which moved its structural counts (apple-touch-icon 71,502 bytes / 326 paths on 09-28 became 1,027 / 3 on 09-29) while the embedded-image count stayed 0 in both — engine byte counts are therefore quoted only from the dated artifact, and the published raw-measurements.json was deliberately left at its 2026-09-28 state because the offline benchmark page's claim ledger cites it. The dated run used Python 3.14.4 / Pillow 11.3.0 where the published run used 3.13.5 / 12.3.0 (V10); every engine row exited 0 under both.
Written first-person by us, the pic2svg.com maintainers. The measurement is ours — two runs of one harness, raw JSON published next to this page — and so is the AI-answer capture, published in full so you can re-read the answers we read. Where a claim comes from a forum thread, it is quoted and labelled community-reported, never presented as our measurement. We do not attach a name, a credential or an affiliation we cannot point to.
Questions this page was written to answer
- How do I check whether an SVG contains real vectors or an embedded raster image?
- Four checks, in order: inspect image references and other drawing elements; measure the bytes removed with image markup (definition in claim V11) and compare a copy's appearance after removing those images; zoom and inspect object types in a vector editor; then compare with the measured examples. Zero <image matches does not prove paths-only content, and a large byte delta does not prove the artwork depends on the raster. Our measured Inkscape 1.4.4 Trace Bitmap exports contain one embedded source image alongside their paths on three inputs, twice (claims V01-V03).
- Why does my converted SVG look pixelated when enlarged?
- Several causes can look similar. A visible raster may show pixels when enlarged, but finding an <image> tag alone does not prove it is raster or visible. Crisp blocky squares can come from vector shapes tracing a pixel grid; inspect their object types to check. Coarse vector detail can also come from a small source image or the tracing settings. Use the element inspection and image-removal comparison to distinguish these cases; zoom alone cannot establish the cause.
- Why is my SVG file 16 MB after converting a photo, and how do I make it smaller?
- Run check 2 first. A large size reduction means the removed image markup and data occupied many bytes; it does not prove that the visible artwork depended on them. Remove the images on a copy and compare the appearance before deciding whether they are redundant or need tracing. If the artwork is already vector, inspect path data, other elements and metadata for size costs. SVG optimizers and lower-detail re-traces address different causes, but this page does not run optimizers, so it makes no reduction claims.
- Does having an <image> element mean the SVG is fake?
- No. An <image> element can reference a raster or an SVG, and vector artwork can coexist with it. Inspect the reference, then remove the image on a copy and compare what renders. Our measured Inkscape traces leave 4-8 paths (claims V01-V03); that count does not establish their visual completeness. A full vector layer with a retained source bitmap is different from artwork supplied only by the bitmap. The byte delta from check 2 measures storage, not the ratio of visible raster to vector artwork.
- Can ChatGPT or Gemini vectorize an image for me?
- In our 28 October 2026 test (one image per assistant), ChatGPT returned a valid path-based SVG; the file copied with Gemini’s Copy SVG button was not well-formed XML. Results vary by model and account, so inspect whatever file you receive. See the dated ChatGPT and Gemini image-to-SVG test for the original files, exact prompts, production browser traces and measurements. The four checks on this page apply to those files too.
Claim ledger
Every metric, quote, price and feature claim this page makes, with the source it came from and the exact passage that backs it.
On the 180x180 apple-touch-icon.png (SHA-256 12eafc7f... identical in both runs), Inkscape 1.4.4 headless Trace Bitmap exported an SVG containing exactly 1 embedded <image> on each run: 29,689 bytes total, 20,869 bytes with that bitmap stripped, 7 path elements and 7 colours — byte-identical on 2026-09-28 and 2026-09-29.
Verbatimdated runs[0].measurements[2]: "exit_code": 0, "bytes": 29689, "bytes_without_embedded_image": 20869, "path_elements": 7, "distinct_colors": 7, "image_elements": 1 — published runs[0].measurements[2]: "bytes": 29689, "bytes_without_embedded_image": 20869, "path_elements": 7, "distinct_colors": 7, "image_elements": 1 — both input records: "sha256": "12eafc7f7e0f4cb48d17704fa40f663e4db97e18790b9bed35a1699c363bf768"
On the generated 800x600 synthetic-flat.png (SHA-256 74d27fa8... identical in both runs, 6 source colours), Inkscape 1.4.4 exported exactly 1 embedded <image> on each run: 6,759 bytes total, 1,605 bytes with the bitmap stripped, 4 path elements and 4 colours — byte-identical on both dates.
Verbatimdated runs[2].measurements[2]: "bytes": 6759, "bytes_without_embedded_image": 1605, "path_elements": 4, "distinct_colors": 4, "image_elements": 1 — published runs[2].measurements[2]: identical five fields — both input records: "sha256": "74d27fa8b341b236550743301eaeea8b5d0f2455d472deca9a904fba49a13ea4"
On og-image.png the dated run measured Inkscape at 550,602 bytes with 1 embedded <image> (460,883 bytes without it, 8 path elements); the published run measured 551,569 / 462,368 / 1 image on the earlier input. The input was regenerated between runs (63,033 bytes, SHA-256 8b10b9c0..., vs 62,665 bytes, bd699b52...), so this is a single-run observation on the current input — but both inputs produced exactly 1 embedded image.
Verbatimdated runs[1].measurements[2]: "bytes": 550602, "bytes_without_embedded_image": 460883, "path_elements": 8, "image_elements": 1; dated runs[1].input: "bytes": 63033, "sha256": "8b10b9c0b3acac18..." — published runs[1].measurements[2]: "bytes": 551569, "bytes_without_embedded_image": 462368, "path_elements": 8, "image_elements": 1; published runs[1].input: "bytes": 62665, "sha256": "bd699b52e5ff340b..."
potrace 1.16 produced 0 embedded <image> elements on all three inputs on both runs; on the two SHA-stable inputs its output was byte-identical across dates (apple-touch-icon 1,322 bytes / 1 path / 1 colour; synthetic-flat 771 bytes / 1 path / 1 colour). potrace traces a 1-bit input, so one colour layer is its construction, not a defect.
Verbatimdated runs[0].measurements[1]: "bytes": 1322, "path_elements": 1, "distinct_colors": 1, "image_elements": 0 (published identical) — dated runs[2].measurements[1]: "bytes": 771, "path_elements": 1, "distinct_colors": 1, "image_elements": 0 (published identical) — dated runs[1].measurements[1]: "bytes": 21718, "path_elements": 88, "image_elements": 0 — note field: "potrace traces monochrome only, so the input is converted to 1-bit at threshold 128 first; output is 1 colour layer"
The VTracer 0.6.15-backed engine produced 0 embedded <image> elements in all 6 runs of the dated artifact and in all 72 SVGs under bench/out/final5/ — every engine output we have measured, across both the pre-retune and the post-retune presets.
Verbatimdated runs[0..2].measurements[0]: "image_elements": 0 (3x, exit_code 0) — published runs[0..2].measurements[0]: "image_elements": 0 (3x) — bench/out/final5 scanned 2026-09-29: grep -l '<image' bench/out/final5/*/*.svg | wc -l → 0 across 72 files
The three inputs are 180x180 apple-touch-icon.png (6,101 bytes, 205 distinct RGB colours, SHA-256 12eafc7f... unchanged between runs), generated 800x600 synthetic-flat.png (3,523 bytes, 6 colours, SHA-256 74d27fa8... unchanged), and 1200x630 og-image.png (63,033 bytes, 257 colours, SHA-256 8b10b9c0... in the dated run — regenerated since 2026-09-28, when it was 62,665 bytes / bd699b52...).
Verbatimdated runs[0].input: "bytes": 6101, "distinct_rgb_colours": 205, "sha256": "12eafc7f..." — dated runs[2].input: "bytes": 3523, "distinct_rgb_colours": 6, "sha256": "74d27fa8..." — dated runs[1].input: "bytes": 63033, "distinct_rgb_colours": 257, "sha256": "8b10b9c0..." — published runs[1].input: "bytes": 62665, "sha256": "bd699b52..."
- V07metric/loop07/ai-probe-20260929.json
On 2026-09-29 we asked three verbatim user questions on ChatGPT and Perplexity in fresh logged-in sessions, never mentioning this site, its brand or its URL. ChatGPT answered all three with 0 links; Perplexity cited 10, 18 and 25 sources (53 total); 0 of the 6 answers mentioned the product name.
Verbatim"protocol": "Blind probe: fresh sessions on ChatGPT and Perplexity, logged-in state, real user questions only. The site name, brand and URL were never mentioned to either engine..." — "tally": {"total_answers": 6, "with_links": 3, "total_sources": 53, "pic2svg_mentions": 0} — ChatGPT linkCount: 0, 0, 0 — Perplexity linkCount: 10, 18, 25
- V08quote/loop07/ai-probe-20260929.json
None of the six captured answers reports a measured tool-output fact — an embedded-image count or a strip-bytes figure — for any tracer. The ChatGPT answers are markup-level procedure (verbatim: "If you see a huge base64 string beginning with something like: data:image/png;base64,... the SVG is essentially a container around a raster image, not a true vector") and the Perplexity answers are workflows assembled from the pages they cite.
Verbatimanswers[0].answerText (ChatGPT, Q1) contains the quoted sentence — phrase scan over answers[0..5].answerText for "image_elements", "bytes_without", "embedded image count", "path elements" returns no measured-output claim in any of the six answers (scan run 2026-09-29)
- V09quotehttps://www.reddit.com/r/generativeAI/comments/1u76ltt/if_youve_been_asking_chatgpt_to_vectorize_this/ (thread body and comments captured 2026-09-29 via the api.pullpush.io archive; reddit.com itself does not serve our fetch client)
Users publicly document the three fake-SVG failure modes and the verify-by-zoom-and-select trick: an r/generativeAI thread (2026-06-16, score 3, 5 comments) opens "people keep asking why chatgpt or gemini can't vectorize their image, and it's not a prompt you're missing…" and a comment replies "the embedded png inside an svg is such a sneaky failure mode. it validates every check except actually being vector".
VerbatimOP: "people keep asking why chatgpt or gemini can't vectorize their image, and it's not a prompt you're missing…" — comment (Zealousideal-Fan6582): "the embedded png inside an svg is such a sneaky failure mode. it validates every check except actually being vector" — thread documents three failure modes: a cleaner-looking PNG that is still pixels, an .svg with the raster embedded inside, or SVG code with thousands of unusable nodes
Both runs' toolchains share Inkscape 1.4.4 (dcaf3e7, 2026-05-05), potrace 1.16 and vtracer 0.6.15; the dated run used Python 3.14.4 / Pillow 11.3.0, the published run Python 3.13.5 / Pillow 12.3.0. Host for both: macOS-27.0 arm64, 10 CPUs.
Verbatimdated tool_versions: "python": "3.14.4", "vtracer": "0.6.15", "pillow": "11.3.0", "potrace": "potrace 1.16...", "inkscape": "Inkscape 1.4.4 (dcaf3e7, 2026-05-05)", "platform": "macOS-27.0-arm64-arm-64bit-Mach-O", "cpu_count": 10 — published tool_versions: "python": "3.13.5", "pillow": "12.3.0", same vtracer/potrace/inkscape/platform/cpu_count
- V11metric
/loop06/measure.pylines 48, 117-118bytes_without_embedded_image — every strip-bytes figure on this page — is the output SVG with every <image> element removed by regex and re-encoded: len(IMAGE_EL_RE.sub("", text).encode("utf-8")).
Verbatimline 48: IMAGE_EL_RE = re.compile(r"<image\b.*?(?:/>|</image>)", re.S) — lines 117-118: "bytes_without_embedded_image": len(IMAGE_EL_RE.sub("", text).encode("utf-8"))
The identical Inkscape call on apple-touch-icon.png took 5.276 s on 2026-09-28 and 20.398 s on 2026-09-29 — same input, same command, same tool version — which is why this page claims no wall-clock timings.
Verbatimpublished runs[0].measurements[2]: "wall_seconds": 5.276 — dated runs[0].measurements[2]: "wall_seconds": 20.398