Automate SVG Metadata Scrubbing for Privacy Compliance

The schema fetch (what you build payloads from)

The GET contract tells you the scrubber is runner-backed, has no options, and must be executed locally. Use it once at startup to confirm the runner mode.

$ curl -H "Authorization: Bearer $JAD_API_KEY" \
    https://jadapps.com/api/v1/tools/svg-metadata-scrubber

{
  "execution": { "runnerBacked": true, "apiAvailable": false,
                 "runnerMode": "headless-browser" },
  "input":  { "isGenerative": false, "acceptsMultiple": false, "options": [] },
  "output": { "type": "svg" },
  "minTier": "free"
}

The call that intentionally 400s

Posting content to JAD's API never works — by design, no file ever reaches JAD. The response hands you the runner endpoint to use instead.

$ curl -X POST -H "Authorization: Bearer $JAD_API_KEY" \
    https://jadapps.com/api/v1/tools/svg-metadata-scrubber/run

HTTP/1.1 400 Bad Request
{
  "error": "Runner required",
  "reason": "JAD's API/MCP never accepts uploads. Pair an @jadapps/runner …",
  "runnerEndpoint": "http://127.0.0.1:9789/v1/tools/svg-metadata-scrubber/run",
  "installRunner": "https://jadapps.com/docs/runner"
}

Batch loop against the local runner (Node)

Pair the runner once, then loop your directory and POST each SVG to localhost. Files stay on your machine; the runner returns cleaned markup.

import { readdir, readFile, writeFile } from "node:fs/promises";

const RUNNER = "http://127.0.0.1:9789/v1/tools/svg-metadata-scrubber/run";
for (const name of await readdir("icons")) {
  if (!name.endsWith(".svg")) continue;
  const svg = await readFile(`icons/${name}`, "utf8");
  const res = await fetch(RUNNER, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ text: svg, options: {} }),
  });
  const out = await res.text();
  await writeFile(`dist/${name.replace(/\.svg$/, "-scrubbed.svg")}`, out);
}

Scrub then minify in one pass

The scrubber leaves comments and the prolog. The minifier is a server-safe engine tool, so the runner can run it in-process — chain them for fully anonymous output.

// after the scrub loop, run the minifier on each scrubbed file:
const MINIFY = "http://127.0.0.1:9789/v1/tools/svg-pro-minifier/run";
const res = await fetch(MINIFY, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ text: scrubbedSvg, options: {} }),
});
// minifier drops <!-- Generator -->, <?xml?>, inter-tag whitespace

A CI gate that fails on leaked metadata

Assert the published output contains no fingerprints. This catches a designer changing an export setting before it reaches production.

# scripts/check-svg-clean.sh
LEAK=$(grep -rlE 'xmlns:(inkscape|sodipodi|dc)|<metadata|dc:creator|docname|absref|Generator' dist/*.svg || true)
if [ -n "$LEAK" ]; then
  echo "Metadata leaked in:"; echo "$LEAK"; exit 1
fi
echo "All SVGs clean."

POST /api/v1/tools/svg-metadata-scrubber/run always returns 400 Runner required. JAD's API never receives uploads — this is the privacy guarantee, not an outage. The response body includes the localhost runnerEndpoint you should call instead. Build against the runner from the start.

The scrubber needs the DOM parser, so it is in headless-browser execution mode and is excluded from the server-safe engine set. The runner handles it by launching headless Chromium locally. Engine-mode tools (like the minifier) run in-process; this one does not.

Without a running, paired runner on 127.0.0.1:9789, there is nowhere to execute the batch. Install and pair it via the runner docs. The web tool still works manually in a browser tab for one-off files.

The scrub set removes <metadata> (author records) but not comments or child-element attributes. An absref path on a nested <image> or an author in a comment will survive. Chain the minifier and run the CI grep gate to catch these before publishing.

Each file is bounded by your tier's per-file limit (5 MB free, 50 MB Pro, 2 GB Developer). An oversized file — usually one with embedded base64 raster — is blocked. Externalise large embedded images or upgrade the tier.

The GET /api/v1/tools/... schema endpoint is rate-limited per API key per hour. You only need to fetch the contract once at startup, not per file. The actual scrubbing happens on the local runner and is not subject to that hourly API rate limit.

Re-scrubbing an already-clean file is a safe no-op: there is no <metadata>/<title>/<desc> left and no editor attributes to remove, so output equals input. This makes the step safe to run on every build without tracking which files were already processed.

Filter your loop to .svg files. Feeding non-SVG content yields a parser-error document with nothing useful to scrub. The example loop above already guards with an extension check.

GDPR-relevant EXIF (GPS, timestamps) inside embedded <image> rasters is not SVG metadata and is not removed by this tool. Strip EXIF from photos before embedding, as a separate pipeline step.