rclone speaks dosya, natively.

Choose your connection

Connect natively. Keep your familiar commands.

Start with the native Dosya backend. Connect with an API key to copy files, move them within your workspace, create share links and check your quota. The S3 gateway covers older rclone builds and existing S3 workflows.

# check your rclone version and available backends
rclone version
rclone help backends

# interactive setup: enter the key at the prompt
rclone config
name> dosya
Storage> dosya
api_key> dos_YOUR_API_KEY
workspace_id> ws_YOUR_WORKSPACE_ID

# list inside the configured workspace
rclone lsf dosya:

# find your configuration file with: rclone config file
# add this section there; replace credentials privately in your editor
[dosya-s3]
type = s3
provider = Other
access_key_id = YOUR_S3_ACCESS_KEY_ID
secret_access_key = YOUR_S3_SECRET_KEY
endpoint = https://api.dosya.dev/s3
region = us-east-1
force_path_style = true
sign_accept_encoding = false
upload_cutoff = 64Mi
chunk_size = 8Mi

rclone lsf dosya-s3:ws_YOUR_WORKSPACE_ID/

Need WebDAV?

Choose WebDAV when your client requires it. A normal upload uses one HTTP request. For large files that should remain single files in the app, use native Dosya uploads or S3 multipart. Mounting storage does not create an independent backup.

Your first transfer

Copy a sample. Read it back. Compare it.

Create a local rclone-test folder with a few small, non-sensitive files. Use the native dosya: remote configured above and choose a new, unique destination folder. copy leaves extra destination files in place, but can replace files with the same name.

# use a small source folder and a NEW destination folder for this check
rclone copy ./rclone-test dosya:rclone-test-UNIQUE/ --dry-run

# review the preview, then upload
rclone copy ./rclone-test dosya:rclone-test-UNIQUE/ --transfers 2 --progress

# read back and compare content without changing either side
rclone check ./rclone-test dosya:rclone-test-UNIQUE/ --one-way --download

Check that the final command reports no differences and exits successfully. --one-way checks that every source file is present; it ignores additional destination files. --download reads content for comparison and uses download allowance. See the rclone check reference.

# macOS / Linux shell; creates a fresh disposable directory
rclone_demo_dir=$(mktemp -d)
mkdir "$rclone_demo_dir/source"
printf 'Dosya rclone sample\n' > "$rclone_demo_dir/source/sample.txt"
rclone copy "$rclone_demo_dir/source" "$rclone_demo_dir/destination" --dry-run
rclone copy "$rclone_demo_dir/source" "$rclone_demo_dir/destination"
rclone check "$rclone_demo_dir/source" "$rclone_demo_dir/destination" --one-way --download

Before you schedule a sync

sync can delete destination files. Preview it with --dry-run, check the source is mounted and populated, and keep an independent backup before enabling a recurring job. A successful listing alone does not prove upload or download access.

Video, RAW photos and archives

Upload in parts. Keep one usable file.

The native Dosya backend uploads large files in parts using the upload layout returned by Dosya. The completed upload is one file that the app can open and share; you do not need a chunker overlay.

Using S3 instead? The fallback setup switches to multipart uploads above 64 MiB, below the gateway's 100 MB single-request ceiling. It starts with 8 MiB parts; rclone may increase part size for very large objects. Keep individual requests below the gateway ceiling. Workspace storage and credential limits still apply.

S3 multipart also produces a single file. A WebDAV chunker overlay instead stores a set of parts that needs the overlay to reconstruct the original.

Start with --transfers 2 and increase only if your connection and limits allow it. Multipart upload does not guarantee that an interrupted process can resume its previous session. For a full content check of an archive, budget the time and download allowance for check --download.

See Dosya S3 settings, rclone multipart uploads and Fair Use limits.

The whole picture

Every operation, native and otherwise.

Server-side copy applies to compatible paths in the same workspace; cross-provider transfers pass through the machine running rclone. S3 empty directories need directory_markers=true.

Recipes

Copy, mount, migrate and share.

These examples use the native dosya: remote above. For a mount, install the OS-specific prerequisites and allow local disk space for the write cache.

# native paths start inside the configured workspace
rclone copy ~/Documents dosya:Documents --dry-run

# after reviewing the preview, copy without deleting extra destination files
rclone copy ~/Documents dosya:Documents --transfers 2 --progress
rclone check ~/Documents dosya:Documents --one-way --download

# create an empty mount point; install your OS's mount prerequisites first
mkdir -p ~/dosya
rclone mount dosya: ~/dosya --vfs-cache-mode writes --dir-cache-time 30s

# unmount in another terminal (use the command for your OS)
fusermount -u ~/dosya  # Linux
umount ~/dosya        # macOS

# cross-provider data passes through the machine running rclone
rclone copy oldS3:my-bucket dosya:Imported --dry-run
rclone copy oldS3:my-bucket dosya:Imported --transfers 2 --progress

# compare content; downloads both sides when needed
rclone check oldS3:my-bucket dosya:Imported --one-way --download

# creates a public Dosya share link; share only files intended for others
rclone link --expire 24h dosya:report.pdf

Reference

Every option, and how the backend behaves.

For the native Dosya backend. The API key is required; select a workspace ID when the key can access several. Compare your build with the upstream reference if its options differ.

Options

# create separate native remotes with interactive rclone config
# work: points to the work workspace; personal: to the personal workspace
rclone copy work:docs/ personal:backup/ --dry-run

# inject RCLONE_DOSYA_API_KEY from your CI secret store
# set RCLONE_DOSYA_WORKSPACE_ID to the chosen workspace
rclone copy ./dist :dosya:releases/ --dry-run

# after reviewing the preview
rclone copy ./dist :dosya:releases/ --transfers 2

Before you point a big job at it

Limits, stated plainly.

These protocol rate limits apply to S3 and WebDAV. Native rclone uses the REST API and its applicable limits. There are no egress fees, but download allowances and credential restrictions still apply.

On the Free plan

WebDAV and S3 skip plan request and concurrency ceilings. Explicit key or role restrictions and abuse rate limits still apply, so tune concurrency to your connection and any rate-limit responses. Lower concurrency does not bypass a daily egress limit.

See Fair Use for the distinction between share-link downloads and API or protocol allowances.

When something fails

• 401 Unauthorized The key is wrong, revoked, or belongs to another account. rclone will not retry this one - check the key, then the workspace ID.
• 429 Too Many Requests You are over the request rate. rclone backs off and retries on its own; on Free, lower --transfers and --checkers rather than waiting it out.
• concurrent_upload_limit Every upload slot in the workspace is busy. rclone waits for one to free up, retrying every 5 seconds for up to 10 minutes, so this is a delay and not a failure unless it lasts that long.
• Upload refused for size A 0-byte file, or a file over the workspace's per-file cap if the admin set one. Neither is retried.
• 500 to 504 A transient server error. rclone retries these automatically; a run that still fails has hit something that needs reporting.

What the backend will not do

• Filenames up to 255 characters.
• Empty files cannot be uploaded. A 0-byte file is rejected.
• Streaming uploads of unknown size are not supported. The size has to be known before the upload starts.
• Upload slots are limited per user, 5 in flight by default and configurable per workspace. With --transfers above that, rclone waits for a free slot rather than failing, retrying every 5 seconds for up to 10 minutes.
• Deleting requests permanent deletion. Do not rely on workspace trash to recover a file removed by rclone.

Open source

Frequently asked questions

Before the first big transfer.