File Uploads ThatNever Start Over
Your user is 80% through a 5 GB upload. Their laptop sleeps. Their connection drops. Their browser closes. With Rilavek, they come back and it picks up exactly where it stopped, down to the byte. You write zero upload handlers.
Resumable file uploads that survive real-world failures
Most upload systems assume a perfect network. We built Rilavek for the internet that actually exists.
No lost progress. No restart from zero. Every time.
Working integration in under 10 minutes
Connect your S3 bucket
Point Rilavek at any S3-compatible bucket in the dashboard. No infrastructure to provision. We generate a Pipe ID you'll use in your frontend.
Issue upload tokens from your server
Your backend exchanges your private Sender key for a short-lived upload token. Your credentials never exposed to the end user or the uploading client.
The file lands in your bucket
Your client streams chunks directly to Rilavek. We handle the retries, the ETag assembly, and the reconnects. You get a webhook when the file is committed to S3.
The official docs lied.
AWS says presigned URLs handle large uploads. Your users say otherwise. Uploads stall. Tabs close. Laptops sleep. When that happens, the browser loses all upload state and your user starts from 0%. AWS never mentioned that part.
The real fix is a full state machine. It requires tracking uploadIds in IndexedDB, managing ETags per chunk, and refreshing presigned URLs before they expire on multi-hour transfers. It is not a weekend project. Most teams build it wrong twice before they give up and cap file sizes at 100 MB.
There is a better way.
Rilavek handles every byte of that state machine for you. Point it at your S3 bucket, drop in four lines of frontend code, and uploads resume automatically even after a tab close, a phone call, or a three-day weekend. You write zero upload handlers.
// 1. Generate a secure token on your server (Node.js) const res = await fetch("https://rilavek.com/api/v1/tokens", { method: "POST", headers: { Authorization: `Bearer ${process.env.RILAVEK_KEY}` }, body: JSON.stringify({ pipeId: "YOUR_PIPE_ID" }), }); const { token } = await res.json(); // 2. Configure Uppy on the frontend import Uppy from "@uppy/core"; import Tus from "@uppy/tus"; import GoldenRetriever from "@uppy/golden-retriever"; const uppy = new Uppy() .use(GoldenRetriever) // Persist state in IndexedDB .use(Tus, { endpoint: "https://upload.rilavek.com/pipes/YOUR_PIPE_ID/files/", headers: { Authorization: `Bearer ${token}` }, chunkSize: 10 * 1024 * 1024, retryDelays: [0, 1000, 3000, 5000], });
Handles real-world failures
Basic upload systems assume perfect networks and stationary devices. Rilavek is built for the chaos of the real internet. Your users never see an upload fail.
How Rilavek compares to the alternatives
Every alternative carries specific trade-offs. Here is where we fit in the landscape.
| Feature | RilavekData Movement | UploadthingNext.js Native | UploadcareUpload UX | CloudinaryMedia Platform | AWS S3DIY Storage | tusdSelf-hosted |
|---|---|---|---|---|---|---|
| Resume across browser restarts | Limited | |||||
| Protocol InteroperabilityHTTP ↔ FTP ↔ S3 | ||||||
| Connect your own storageFiles land directly in your AWS/GCP bucket | Via adapter | |||||
| No vendor lock-inOpen TUS standard | ||||||
| Multi-cloud fan-out out of the box | ||||||
| No backend infra to manage | ||||||
| Built-in image/video processing | Upload focused |
Everything a multipart upload handler needs to do, handled for you
These are the failure modes that always come up in production. We handle every one of them.
Secure Token Auth
Short-lived upload tokens mean your root credentials never leave your server.
True Resume-on-Crash
TUS tracks the last committed byte. Network flaps do not restart the upload.
Direct S3 Streaming
Chunks stream directly to S3. No intermediate disk writes or memory bottlenecks.
Any TUS Client
Works with Uppy, tus-js-client, or any compliant library. Un-opinionated.
Automatic Retries
The server handles chunk-level retries with configurable backoff. Silent failovers.
Data Integrity
Chunk validation and final file checksums before completion. No silent part failures.
Upload Visibility
Upload IDs, chunk-level status, and progress APIs. Treat uploads as a traceable system.
Multi-Cloud Fan-out
A single browser upload fans out to AWS, GCP, and Cloudflare R2 concurrently.
Built for real use cases
Video Platforms
GB-scale media uploads that don't timeout.
Backup Tools
Long-running data pipelines in the background.
Data & ML
Massive datasets from unstable field connections.
SaaS Platforms
White-label uploads into your own buckets.
Not magic. Open standard.
The resumability is powered by TUS, an open protocol for resumable uploads used by Vimeo, GitHub, and others. Every upload offset is tracked server-side. Chunks are committed atomically. If a transfer stops for any reason, Rilavek knows exactly where to continue. You never write a single multipart handler.
Works with any TUS-compatible client, not just JavaScript
TUS is an open protocol. If a client speaks TUS, it works with Rilavek. This includes your own implementations.
Uppy is the most widely-used open-source JavaScript file upload library. It ships TUS support as a first-class plugin and covers every major frontend framework. Rilavek is fully compatible with Uppy. Point it at your endpoint and resumable uploads work out of the box.
React
Angular
Vue
Svelte
Next.js
NuxtCommon questions
Does this work for files over 5 GB?
Yes. There is no practical file size limit. We use S3 multipart uploads under the hood, which supports objects up to 5 TB. TUS chunks ensure stable delivery regardless of file size.
Does this work with mobile apps, not just browsers?
Yes. Because Rilavek implements the standard TUS protocol, any compliant client works, including tus-android-client and tus-ios-client.
What happens if S3 fails mid-assembly? Are partial multipart uploads cleaned up?
Rilavek automatically handles cleanup of orphaned chunks and aborted multipart uploads on your storage provider after a 24-hour expiry using lifecycle rules.
How do I get notified when an upload completes?
Configure a webhook URL on your Pipe. Rilavek fires a POST request to your endpoint with the file URL, size, and metadata as soon as S3 confirms the assembly.
Do my users need to install anything?
No. Your frontend only needs a TUS client library like Uppy. There is no agent or browser extension. The upload endpoint is a plain HTTPS URL.
What happens if the user closes the browser tab mid-upload?
If you use the GoldenRetriever Uppy plugin, upload state persists in IndexedDB. When the user returns to the page, Uppy queries our TUS server for the last committed offset and resumes from there automatically. No restart needed.
Can I use this with Cloudflare R2, MinIO, or other S3-compatible storage?
Yes. Rilavek supports any S3-compatible API. Configure your Pipe to point to your Cloudflare R2 bucket, MinIO instance, or Backblaze B2. The upload flow is identical to AWS S3.
How is this different from running my own tusd server?
Running tusd yourself means handling storage backends, auth middleware, orphaned file cleanup, and horizontal scaling. Rilavek provides all of that as a managed service. You get a production-ready TUS endpoint in minutes, not days.
Beyond HTTP
Have legacy systems?
Rilavek isn't just for browsers. You can stream files directly into S3 using standard FTP or SFTP clients with the exact same resumability.
Read about legacy protocols →Stop writing upload infrastructure.
A working TUS endpoint, pointed at your S3 bucket, in under ten minutes. Read the integration guide or start for free.
Free plan includes 10GB of transfer. No credit card required.