EXPORT INFRASTRUCTURE FOR PRODUCT TEAMS
“Download all as ZIP,” at any scale.
Send us a list of URLs. We build the archive and hand your users an expiring signed link. ZIP64, streaming, retries, storage and cleanup are our problem now — so your team doesn’t build ZIP infrastructure to ship one export button.
20 GB/mo free · No credit card · Hard-capped, no surprise bills
MIT-licensed SDK on GitHubIn production: 7.6M+ files · 100 TB+ zippedZero egress fees
Two ways in · one product
Start from the browser, or from your server
Same jobs, same archives, same dashboard. Pick the entry point that matches your stack.
@eazip/core · pk_ez_
Already using the SDK? Cloud is one option away.
Same API, same tray. The only thing that changes is where the job runs — so tab memory, CORS limits and “reload killed my download” stop being your ceiling.
HTTP API · zk_
No frontend SDK needed. One POST.
Post a list of files, get a job back. Poll it or take the webhook, then hand the signed URL to your user. Choose stored to build once and keep it, or stream to zip on the fly.
import { startZip } from '@eazip/core'
const job = startZip({
strategy: 'cloud',
publicKey: 'pk_ez_…',
files: selectedUrls,
})
const result = await job.done
result.download() // same tray, survives reloadscurl -X POST https://api.eazip.io/jobs \
-H "X-API-Key: zk_…" \
-d '{
"zip_filename": "invoices-2026.zip",
"mode": "stored",
"files": [{ "url": "https://…/inv-01.pdf" }]
}'
// → { "success": true, "job_id": "550e8400-…" }
// webhook → { "download_url": …, "expires_at": … }What you stop building
The export button is easy. The rest isn’t.
Every team that ships a bulk download rebuilds the same six things — and then maintains them.
ZIP64 and the 4 GB compatibility swamp
ZIP64 always on, splitting handled for you
Archives that don’t fit in memory
Streamed generation — size-independent
Flaky source URLs and half-finished jobs
Retries, checkpoint resume, and a failure policy you choose
Temp files and a cleanup cron
Storage, retention and deletion included
Paying egress on every re-download
Signed-URL delivery with no egress charge
In-browser zipping that dies on memory, CORS or reload
The SDK tray and resume, backed by the cloud job
How it works
URLs in, signed ZIP out
1
Send URLs
Hand us a list of (presigned) S3, R2 or CDN URLs — from the browser with a publishable key, or from your server with an API key.
2
We build the ZIP
Streaming ZIP64 with checkpoint resume. Pick a split size and big jobs fan out into multiple archives — your plan sets the total per job.
3
Users download
An expiring signed URL with Range support. Stored keeps the archive around; stream zips it on the fly.
4
Lifecycle handled
Webhooks on completion, retention windows per plan, automatic cleanup. Nothing left for you to sweep up.
Up to 20,000 files and 500 GB total per job on the Scale plan · each archive caps at 50 GB — see pricing for per-plan limits.
Built for teams shipping bulk downloads
SaaS product teams
“Download all attachments,” invoice bundles, report exports, audit-trail archives — the request every B2B customer eventually files.
Typical entry point: Server API, or the SDK for user-triggered exports
E-commerce & Shopify apps
Deliver digital products as one bundle, or let merchants pull down a whole product’s image set in a click.
Typical entry point: Server API
Media & assets on S3/R2
DAM and photo-delivery flows: the client selects 400 RAW files and gets one link. Zero egress makes the math work.
Typical entry point: Browser SDK + R2
Capabilities
Build
ZIP64 by default
Multi-archive splitting with your chosen split size
Stored and stream modes
Explicit filenames and guaranteed order
Deliver
Expiring signed URLs
HTTP Range / resumable downloads
No egress fees
Per-plan retention windows
Operate
Completion and failure webhooks
Dashboard with job history
Per-file error detail
Automatic cleanup
Control
Public Apps: origin and source-host allowlists
Publishable keys safe to ship in frontends
Hard quota caps
Overage optional — switch it off to cap your bill
Built in production
We run our own file-sharing product on it
Eazip started as the export layer for our own file-sharing service, and it still carries that traffic every day. The SDK your users run is MIT-licensed and public; the engine behind it has been zipping real customer archives since long before this page existed.
9,000+
jobs run
14,000+
archives built
7.6M+
files zipped
100 TB+
archived volume
Pricing
Start free. No surprise bills.
Free is hard-capped — no card, no invoice. On paid plans overage is optional: switch it off and your bill is capped at the subscription price.
Free
$0 /mo
Evaluate the API end to end.
Stream 20 GB/mo
Stored 100 GB-days/mo
Retention 1 day
Files per job 100
Max total per job 5 GB
Starter Popular
$9 /mo
Your first production export.
Stream 500 GB/mo
Stored 3,000 GB-days/mo
Retention 7 days
Files per job 1,000
Max total per job 25 GB
Pro
$29 /mo
Export is a core workflow.
Stream 3 TB/mo
Stored 20,000 GB-days/mo
Retention 60 days
Files per job 5,000
Max total per job 100 GB
Scale
$99 /mo
High volume, large archives.
Stream 20 TB/mo
Stored 75,000 GB-days/mo
Retention 90 days
Files per job 20,000
Max total per job 500 GB
Pay-as-you-go on paid plans: stream $0.004/GB · stored $0.002/GB-day — optional. Switch it off and jobs stop at the quota instead.
Public Apps can cap size per session — so a publishable key in your frontend has a
provable billing ceiling.
More volume, custom retention or an SLA? support@eazip.io
or ping us on Discord.
Before you sign up
Stream builds the ZIP on the fly as the user downloads it — nothing is kept, and you’re billed per GB streamed. Stored builds the archive once, keeps it for your plan’s retention window, and is billed per GB-day. Use stored when the same archive may be downloaded more than once or shared by link.
The job is blocked. Free accounts are hard-capped: no overage, no card on file, no invoice. On paid plans overage is optional — switch it off and jobs stop at the included quota instead, which caps your bill at the subscription price.
Yes. Browser integrations use a publishable key (pk_ez_…) scoped by a Public App, which restricts allowed origins and source hosts and can cap size per session. Secret API keys stay on your server.
Yes — that’s the intended input. Any URL we can fetch works, and short-lived presigned URLs are the recommended way to keep private objects private.
By default the whole job fails if any source can’t be fetched (fail_on_url_error defaults to true), so you never ship an incomplete archive by accident. Set it to false to skip failed sources and deliver the rest. Per-file errors are visible in the dashboard either way.
Stored archives live in Cloudflare R2 until your plan’s retention window ends, then they’re deleted automatically. Stream archives are never kept — they’re generated during the download. Source files are never persisted in either mode; we only read them while building the archive.
Depends on the plan: from 100 files and 5 GB total per job on Free up to 20,000 files and 500 GB total per job on Scale. Individual archives cap at 50 GB on every plan — for bigger jobs, set a split size (max_zip_size_bytes) and the job fans out into multiple ZIPs.
Often. If you’re zipping a handful of files, under a few hundred MB, and you control CORS on the sources, local mode in @eazip/core does it for free with no account. Cloud earns its keep when jobs get big, slow, or need to survive a reload.
Ship the export button this week.
20 GB/mo free · no credit card · hard-capped.
Just want to try the open-source SDK first?
npm i @eazip/react ·
eazip.io