Measure Compressed SVG Sizes in Bulk with the JAD Runner

Confirm the public /run endpoint is upload-free

POSTing content to the public endpoint does not run the tool — it returns 400 with instructions to use your local runner. This is the expected, documented behaviour.

$ curl -s -X POST https://jadapps.com/api/v1/tools/svg-compression-estimator/run \
    -H "Authorization: Bearer $JAD_API_KEY" \
    -H 'Content-Type: application/json' -d '{"input":"<svg/>"}'

{
  "error": "Runner required",
  "reason": "JAD's API/MCP never accepts uploads. Pair an @jadapps/runner...",
  "schemaEndpoint": ".../api/v1/tools/svg-compression-estimator",
  "runnerEndpoint": "http://127.0.0.1:9789/v1/tools/svg-compression-estimator/run",
  "installRunner": ".../docs/runner"
}

Fetch the schema to confirm no options

The schema endpoint tells you the estimator is a free-tier engine tool with an empty options array — so your runner payload only needs the SVG content.

$ curl -s https://jadapps.com/api/v1/tools/svg-compression-estimator \
    -H "Authorization: Bearer $JAD_API_KEY" | jq '{minTier, execution, input}'

{
  "minTier": "free",
  "execution": { "runnerMode": "engine", "runnerBacked": true, "apiAvailable": false },
  "input": { "isGenerative": false, "acceptsMultiple": false, "options": [] }
}

Estimate one file on the local runner

POST the SVG content to the paired runner on localhost. It returns the text report, which you parse for the gzip line.

$ curl -s -X POST http://127.0.0.1:9789/v1/tools/svg-compression-estimator/run \
    -H 'Content-Type: application/json' \
    --data "$(jq -Rs '{input: .}' < dist/icons/menu.svg)"

Raw:    4.1 KB (4,182 bytes)
Gzip:   1.3 KB — 68% savings
Brotli: 1.1 KB — 74% savings

Enforce a 10 KB gzip budget in a CI script

Loop over every built SVG, parse the gzip byte count from the runner's report, and fail the build if any file exceeds the budget.

#!/usr/bin/env bash
set -euo pipefail
BUDGET=10240   # 10 KB gzipped per SVG
fail=0
for f in dist/icons/*.svg; do
  report=$(curl -s -X POST http://127.0.0.1:9789/v1/tools/svg-compression-estimator/run \
    -H 'Content-Type: application/json' --data "$(jq -Rs '{input: .}' < "$f")")
  # parse the (NN bytes) on the Gzip line via raw bytes -> recompute, or read KB:
  kb=$(awk -F'[ ]' '/^Gzip:/ {print $2}' <<<"$report")
  echo "$f -> $kb gzip"
  # convert KB to bytes for the comparison in your language of choice
done
exit $fail

Pair the runner's gzip with a real brotli check

Because the report's brotli line is a heuristic, run a real brotli encoder alongside for an exact brotli budget — best of both: JAD's accurate gzip and a true brotli size.

for f in dist/icons/*.svg; do
  # exact gzip from JAD runner report (parse bytes), exact brotli from CLI:
  brotli -q 11 -k "$f"                 # writes f.br
  brsize=$(stat -c%s "$f.br")
  echo "$f  brotli(real)=$brsize bytes"
  [ "$brsize" -gt 8192 ] && { echo "OVER 8KB brotli: $f"; exit 1; }
done

The public /api/v1/tools/.../run endpoint never executes with an upload. It validates your key, checks rate limits, and returns 400 with runnerEndpoint and installRunner fields. Your pipeline must target the local runner on 127.0.0.1:9789, not jadapps.com.

The estimator returns a plain-text report, not a structured JSON object. There are no raw_bytes / gzip_bytes / gzip_ratio fields. Parse the Raw: / Gzip: / Brotli: lines from the text. The browser version names them Raw size / Gzip estimate / Brotli est.; the engine version uses Raw: / Gzip: / Brotli:.

The estimator's minTier is free. Any valid API key can fetch its schema and run it on the runner. The tier ceilings that do apply are file-size limits (5 MB free / 50 MB Pro / 2 GB Developer), not a plan gate on the tool itself.

If @jadapps/runner isn't started, the localhost POST gets connection-refused. Start it before the CI step (or run it as a service on the build agent) and confirm it's listening on 9789. The public API can't substitute — it's upload-free by design.

The report's brotli figure is gzip × 0.82, not a measurement. A budget pegged to it can pass when real brotli is larger (tiny icons) or be needlessly strict when real brotli is smaller (large sprites). Budget on the gzip line, and add a real brotli -q 11 step if brotli is your contractual number.

An SVG above the tier's per-job ceiling (5 MB free) is rejected. SVGs this large almost always embed base64 rasters; extract the raster and serve it separately rather than raising the limit. The estimator has no row/element count limit — only the file-byte cap.

The schema GET is rate-limited per API key (the response carries X-RateLimit-* headers). For a big batch, fetch the schema once and cache it — the per-file runs go to your local runner and don't consume the JAD rate limit. A 429 returns resetAt.

The report prints (4,182 bytes) with a thousands separator from toLocaleString(). Strip commas before converting to an integer, or read the KB figure and multiply. Don't assume a raw integer is present without separators.