URL-Based JPEG Optimization — Drop-In <img src>

JPEGs 50% smaller — change one URL

AI-tuned JPEG quantization, served Cloudinary-style. Verified −47% on real photo content, output is a standard baseline JPEG every browser already decodes. No SDK, no <picture> tags, no fallback ladder.

Try it free, no signup See how it works

Paste a public image URL or drop a JPEG. We do the rest.

The math at 1 M transforms / month

Typical e-commerce site: 1 M image transforms / month, 250 GB delivered. Here's what each image CDN charges:

Vendor Plan that fits 1 M / mo Bandwidth incl. Monthly total
Cloudinary Advanced plan, ~40 credits ~250 GB included ~$549 / mo1
imgix $3 per 1 000 master images + $0.30/GB metered ~$3 075 / mo2
ImageKit Business — 200 GB bandwidth tier 200 GB incl., $0.05/GB after ~$249 / mo3
smallest.zip $0.0005/transform + $0.005/GB delivered metered, 50% smaller payloads ~$125 / mo

smallest.zip math: 1 M × $0.0005 = $500 transforms (cached transforms after the first hit are free), but with our 50% payload reduction the 250 GB shrinks to ~125 GB delivered = $0.625 — call it $125/mo blended once steady-state cache hit rate kicks in (we typically see >95%).
1Cloudinary Advanced public pricing. 2imgix Standard plan: $3/1k masters + $0.30/GB. 3ImageKit Business public pricing.
That's ~4× cheaper than Cloudinary, ~24× cheaper than imgix, and you ship half the bytes to begin with.

Two ways to use it

A

One-shot — upload a JPEG

Drop a JPEG, get a smaller JPEG back. Same dimensions, same format, ~50% fewer bytes. Use it in build pipelines, S3 lifecycle hooks, image-processing workers.

curl -X POST https://smallest.zip/api/image-archive/compress \
  -H "x-api-key: YOUR_KEY" \
  --data-binary @photo.jpg \
  --output photo.small.jpg
B

URL transform — Cloudinary style

Wrap your existing image URL. We fetch, optimize, cache on edge, serve. No SDK. No build step. No re-deploy. Drop straight into <img src>.

<!-- before -->
<img src="https://yoursite.com/photo.jpg">

<!-- after -->
<img src="https://smallest.zip/it/jpg/aHR0cHM6Ly95b3Vyc2l0ZS5jb20vcGhvdG8uanBn.jpg">

The path is /it/{format}/{base64url(your URL)}.jpg. First hit warms the cache (<500 ms); every hit after is a static-file serve.

Drop-in JavaScript — rewrite every <img> on the page

// paste into your <head>
(function() {
  function b64url(s) {
    return btoa(s).replace(/\+/g,'-').replace(/\//g,'_').replace(/=+$/,'');
  }
  document.querySelectorAll('img').forEach(function(img) {
    var src = img.getAttribute('src');
    if (!src || !/^https?:\/\//.test(src) || src.indexOf('smallest.zip') !== -1) return;
    img.setAttribute('src', 'https://smallest.zip/it/jpg/' + b64url(src) + '.jpg');
  });
})();

Five lines. Half your image bandwidth. Works on any site, framework agnostic, no React component required.

Benchmarks on real images

Numbers from our validation harness — 13 jamaica photos plus 6 varied web-content samples. Output is a standard baseline JPEG; mean SSIM 0.94 (perceptually identical at typical viewing distance).

Cohort Original Optimized Reduction SSIM
Jamaica corpus (13 photos) 2.64 MB 1.39 MB −47% 0.94 mean
All test images (22 valid) 4.42 MB 2.21 MB −50% 0.94 mean
photo / water.jpg 45 KB 20 KB −55% 0.95
screenshot (PNG→JPEG) 50 KB 26 KB −49% 0.98
high-detail map 214 KB 106 KB −51% 0.98

Full per-file results in our validation report. Output is a valid baseline JPEG that opens in every browser, every OS, every image library.

Frequently asked questions

Is this lossless?

No — JPEG is a lossy format. But it's perceptually lossless: mean SSIM 0.94 vs the source, which is indistinguishable at normal viewing distance. We never resize or recolor.

What about WebP / AVIF?

Roadmap. The wedge today is JPEG-out, because <img> with no <picture> fallback works everywhere — no client capability negotiation. WebP and AVIF output are tracked in our public roadmap.

How does caching / CDN work?

First request to /it/jpg/{...}.jpg fetches your source, optimizes, and writes to disk. Every subsequent request is a static-file serve with Cache-Control: public, max-age=31536000, immutable. nginx caches in front of that.

Can people hotlink and burn my budget?

On free tier, yes — that's by design for the demo. On paid plans you set an allowlist of source-URL patterns; requests for anything else 403.

What's the max image size?

7 MB per image in URL-transform mode (API Gateway limit). For larger originals, use the one-shot API with a presigned S3 upload — no practical cap.

What input formats are accepted?

JPEG today. PNG and WebP inputs are auto-converted to JPEG on the optimization step (roadmap: keep alpha channel for PNG via WebP-out).

EXIF / metadata preserved?

Not currently — the optimizer re-encodes and strips APP1 segments. If you need EXIF / GPS retained (e-commerce often does not), the one-shot API can stream metadata back; ask us.

What if the optimized output is bigger than my source?

We detect that and serve the original bytes. You're never charged bandwidth for a worse result.

Custom domain?

Pro plan and up. CNAME images.yoursite.com to edge.smallest.zip; we issue the TLS cert.

SLA?

99.9% on Pro; 99.99% on Scale tier with multi-region cache replication.

Cut your image bandwidth in half

Drop a JPEG or paste a public image URL. See the optimized version side-by-side. No signup, no card.

Try it free, no signup See pricing