ReboFilesDocs
Start3
What is ReboFiles
Getting started
Demos to run
Put it in your app6
React component
Headless: your own UI
Without a framework
Styling and themes
Keyboard and accessibility
Languages
Files9
Uploads
Previews and the viewer
Search
Live changes and large folders
Comments
Starred and fields
Versions, trash and space
Download as .zip
Word documents
The server14
The route
Frameworks and sign-in
Who may do what
Storage: S3, GCS, Azure and disk
Checking uploads
Metadata: SQLite and Postgres
Database schema
Sharing and links
Activity and notifications
Hooks, logs and limits
Retention, holds and export
Desktop and other origins
Sync a folder
Going to production
Together1
AI assistants (MCP)
Reference5
Packages
Components and hooks
Client API
HTTP routes
Status and roadmap
↑↓ to move↵ to openEsc to close38 pages

Files Uploads

Uploads

By the button, by dropping files, or a whole folder of the computer. The browser sends the bytes straight to the bucket; the server only signs where to, checks what arrived, and lists it.

tip: drop a whole folder on the drive

How

In parts, to the bucket

A file larger than 8 MiB goes in parts, each to an address signed for its exact length, a few at once.

  • POST /uploads says where to send each part; the parts go to the bucket; POST /uploads/finish puts them together, and the server checks the size that arrived before the file is listed.
  • A part that fails is tried again, five times with a longer wait each, from what arrived. Files of up to 5 GiB unless maxSize says otherwise.
  • The bucket must expose ETag in its rule of origins: the page reads it from each part, and the server needs it to put them together.
Watch

The panel of uploads

Three files at once; each says how much has gone, how fast and how long it has left, and so does all of it together.

One is stopped, and what of it arrived taken away; one that failed is tried again from what arrived. The speed is that of the last few seconds, so a time left follows a change without jumping at every jolt.

const { uploads, summary } = useUploads({ check: true });
// summary.remaining: seconds until all are up, at the speed all go at together
// uploads[i].remaining: the same, of one
Resume

Resumed after a cut

An upload cut, or left when the page closed, goes on from where it was when the same file is uploaded again to the same place.

// A file cut halfway, or left when the page closed, is uploaded again:
await client.upload(file, { parent });  // asks the server what arrived, sends the rest

The page remembers it in localStorage for a day, as long as the server keeps the parts. One never gone on with waits in the bucket for a lifecycle rule (“abort incomplete multipart uploads after 1 day”).

Folders

Whole folders

Dropped on the drive, or chosen with “Upload a folder”, a folder goes up with all that is in it: its folders made top down, the empty ones too, “(2)” for a name taken there.

Duplicates

The same file, asked about

Before each file goes, it is looked for in the drive.

FoundAsked
The same bytes, anywhere one may readUpload anyway, or skip.
A file of its name where it goesReplace it (a new version of it), keep both (“(2)”), or skip.

The bytes are told by a SHA-256 made in the page, for files of up to 64 MiB, kept with the version (POST /duplicates finds it). “Do the same for all the others” answers every one of a kind at once. checkUploads={false} uploads without asking.

After

What goes with it

Made in the page and sent after the file, which is up whether or not they are.

  • Of a picture, copies in the drive’s four sizes and a placeholder of a few pixels: Previews.
  • Of a text file or a Word document, what is written in it: Search.