Automate SVG Path Simplification Across an Icon Library

Discover the schema

Fetch the contract before building any payload. This is the authoritative list of options — a single number.

$ curl -s https://jadapps.com/api/v1/tools/svg-path-simplifier
{
  "slug": "svg-path-simplifier",
  "category": "performance",
  "outputType": "svg",
  "minTier": "pro",
  "acceptsMultiple": false,
  "options": [
    { "name": "tolerance", "type": "number",
      "default": 1.0, "min": 0.1, "max": 5, "step": 0.1 }
  ],
  "execution": { "runnerMode": "engine" }
}

The cloud /run endpoint refuses uploads

This is expected behaviour, not an error in your code. The 400 hands you the runner endpoint to use instead.

$ curl -s -X POST https://jadapps.com/api/v1/tools/svg-path-simplifier/run \
     -H "Authorization: Bearer $JAD_KEY" --data @icon.svg
{
  "error": "Runner required",
  "reason": "JAD's API/MCP never accepts uploads ...",
  "schemaEndpoint": ".../api/v1/tools/svg-path-simplifier",
  "runnerEndpoint": "http://127.0.0.1:9789/v1/tools/svg-path-simplifier/run",
  "installRunner": ".../docs/runner"
}

Node loop over a directory via the local runner

The actual batch pattern: read each SVG, POST to the runner one file at a time, write the result. No ZIP, no cloud upload.

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

const RUNNER = "http://127.0.0.1:9789/v1/tools/svg-path-simplifier/run";
const TOL = 1.0;

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: { tolerance: TOL } }),
  });
  const out = await res.text();
  await writeFile(`./icons-out/${name}`, out);
}

Per-category tolerance

Run the loop once per subdirectory with a different value. Keep each value inside 0.1–5.0 or the runner rejects it.

const jobs = [
  { dir: "./icons/geometric",   tolerance: 0.5 },  // crisp polygons
  { dir: "./icons/traced",      tolerance: 2.0 },  // rough bitmap traces
];
for (const j of jobs) await simplifyDir(j.dir, j.tolerance);
// out-of-range example:
//   tolerance: 9  → 400 'Option "tolerance" must be \u2264 5 (received 9).'

npm script + visual regression gate

Wire the loop into package.json and follow it with a snapshot check so over-simplified polylines fail CI.

// package.json
{
  "scripts": {
    "icons:simplify": "node scripts/simplify-icons.mjs ./src/icons",
    "icons:check": "npm run icons:simplify && playwright test icons.spec.ts"
  }
}
// curve/H/V icons pass through untouched, so they never regress;
// only eligible polylines can differ — those are what the snapshot guards.

/api/v1/tools/svg-path-simplifier/run always returns 400 "Runner required" with pairing instructions — it never accepts upload content. If your pipeline treats that as a hard failure, you've misread the contract: the 400 body carries the runnerEndpoint you should dispatch to instead. Files only ever process on your own paired runner.

acceptsMultiple is false for this tool (only svg-sprite-builder accepts multiple inputs), and there is no /optimize-paths or ZIP-returning endpoint. "Batch" is your script looping one file per runner call. Any older doc referencing a 50-files-per-call ZIP endpoint or a files-per-call rate limit is describing functionality that does not exist.

The schema validator enforces 0.1–5.0. A value below 0.1 or above 5.0 throws Option "tolerance" must be \u2265 0.1 / \u2264 5, and a non-numeric value throws must be a number. The browser slider clamps the same range, so the web and API entry points agree. Clamp client-side before dispatching to avoid round-trips.

Bézier/arc icon sets are skipped entirely — the runner returns the SVG unchanged with Curve paths preserved equal to the path count. In a batch this looks like "no savings" on those files, which is correct: the tool only simplifies M/L polylines. Don't add a retry loop expecting curves to eventually shrink; they won't.

Paths using H/V shorthand are excluded by the eligibility regex even though they're straight. If your traced output uses H/V, normalise them to explicit L commands in a pre-pass (SVGO can do this) so the simplifier can act on them.

SVG limits are 5 MB (free), 50 MB (Pro), 2 GB (Developer). The tool is Pro-minimum, so a free key can't run it at all. In a batch, pre-filter by size or catch the per-job-limit error and route oversized assets to a Developer-tier runner.

If the runner isn't running, your POST to http://127.0.0.1:9789/... fails at the network layer (connection refused), not with a JAD HTTP status. Health-check the runner before the loop and surface a clear "pair the runner" message; see /docs/runner.

Authenticated cloud calls (schema fetch, the deliberate /run 400) count against your key's hourly rate limit and return 429 with X-RateLimit-* headers when exceeded. The actual simplification runs locally on the runner and does not consume cloud quota — so fetch the schema once and cache it rather than per file.