neulab/tldr huggingface dataset:
Autostart on Windows The most relevant alternatives for autostart on Windows are: - Run at user log on using the Startup folder - Run at user log on, at system startup or at schedule using Task Scheduler - Run at system startup using Windows service
Running in background Rclone is a console application, so if not starting from an existing Command Prompt, e.g.  when starting rclone.exe from a shortcut, it will open a Command Prompt window.  When configuring rclone to run from task scheduler and windows service you are able to set it to run hidden in background.  From rclone version 1.54 you can also make it run hidden from anywhere by adding option --no-console (it may still flash briefly when the program starts).  Since rclone normally writes information and any error messages to the console, you must redirect this to a file to be able to see it.  Rclone has a built-in option --log-file for that.
Example command to run a sync in background:
c:\rclone\rclone.exe sync c:\files remote:/files --no-console --log-file c:\rclone\logs\sync_files.txt
User account As mentioned in the mount (https://rclone.org/commands/rclone_move/) documentation, mounted drives created as Administrator are not visible to other accounts, not even the account that was elevated as Administrator. By running the mount command as the built-in SYSTEM user account, it will create drives accessible for everyone on the system.  Both scheduled task and Windows service can be used to achieve this.
NOTE: Remember that when rclone runs as the SYSTEM user, the user profile that it sees will not be yours.  This means that if you normally run rclone with configuration file in the default location, to be able to use the same configuration when running as the system user you must explicitely tell rclone where to find it with the --config (https://rclone.org/docs/#config-config-file) option, or else it will look in the system users profile path (C:\Windows\System32\config\systemprofile).  To test your command manually from a Command Prompt, you can run it with the PsExec (https://docs.microsoft.com/en-us/sysinternals/downloads/psexec) utility from Microsoft's Sysinternals suite, which takes option -s to execute commands as the SYSTEM user.
Start from Startup folder To quickly execute an rclone command you can simply create a standard Windows Explorer shortcut for the complete rclone command you want to run.  If you store this shortcut in the special "Startup" start-menu folder, Windows will automatically run it at login.  To open this folder in Windows Explorer, enter path %APPDATA%\Microsoft\Windows\Start Menu\Programs\Startup, or C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp if you want the command to start for every user that logs in.
This is the easiest approach to autostarting of rclone, but it offers no functionality to set it to run as different user, or to set conditions or actions on certain events.  Setting up a scheduled task as described below will often give you better results.
Start from Task Scheduler Task Scheduler is an administrative tool built into Windows, and it can be used to configure rclone to be started automatically in a highly configurable way, e.g.  periodically on a schedule, on user log on, or at system startup.  It can run be configured to run as the current user, or for a mount command that needs to be available to all users it can run as the SYSTEM user.  For technical information, see https://docs.microsoft.com/windows/win32/taskschd/task-scheduler-start-page.
Run as service For running rclone at system startup, you can create a Windows service that executes your rclone command, as an alternative to scheduled task configured to run at startup.
Mount command built-in service integration For mount commands, Rclone has a built-in Windows service integration via the third party WinFsp library it uses.  Registering as a regular Windows service easy, as you just have to execute the built-in PowerShell command New-Service (requires administrative privileges).
Example of a PowerShell command that creates a Windows service for mounting some remote:/files as drive letter X:, for all users (service will be running as the local system account):
New-Service -Name Rclone -BinaryPathName 'c:\rclone\rclone.exe mount remote:/files X: --config c:\rclone\config\rclone.conf --log-file c:\rclone\logs\mount.txt'
The WinFsp service infrastructure (https://github.com/billziss- gh/winfsp/wiki/WinFsp-Service-Architecture) supports incorporating services for file system implementations, such as rclone, into its own launcher service, as kind of "child services".  This has the additional advantage that it also implements a network provider that integrates into Windows standard methods for managing network drives.  This is currently not officially supported by Rclone, but with WinFsp version 2019.3 B2 / v1.5B2 or later it should be possible through path rewriting as described here (https://github.com/rclone/rclone/issues/3340).
Third party service integration To Windows service running any rclone command, the excellent third party utility NSSM (http://nssm.cc), the "Non-Sucking Service Manager", can be used.  It includes some advanced features such as adjusting process periority, defining process environment variables, redirect to file anything written to stdout, and customized response to different exit codes, with a GUI to configure everything from (although it can also be used from command line ).
There are also several other alternatives.  To mention one more, WinSW (https://github.com/winsw/winsw), "Windows Service Wrapper", is worth checking out.  It requires .NET Framework, but it is preinstalled on newer versions of Windows, and it also provides alternative standalone distributions which includes necessary runtime (.NET 5).  WinSW is a command-line only utility, where you have to manually create an XML file with service configuration.  This may be a drawback for some, but it can also be an advantage as it is easy to back up and re-use the configuration settings, without having go through manual steps in a GUI. One thing to note is that by default it does not restart the service on error, one have to explicit enable this in the configuration file (via the "onfailure" parameter).
Autostart on Linux Start as a service To always run rclone in background, relevant for mount commands etc, you can use systemd to set up rclone as a system or user service.  Running as a system service ensures that it is run at startup even if the user it is running as has no active session.  Running rclone as a user service ensures that it only starts after the configured user has logged into the system.
Run periodically from cron To run a periodic command, such as a copy/sync, you can set up a cron job.
Usage Rclone is a command line program to manage files on cloud storage.  After download (https://rclone.org/downloads/) and install (/install), continue here to learn how to use it: Initial configuration, what the basic syntax looks like, describes the various subcommands, the various options, and more.
Configure First, you'll need to configure rclone.  As the object storage systems have quite complicated authentication these are kept in a config file. (See the --config entry for how to find the config file and choose its location.)
The easiest way to make the config is to run rclone with the config option:
See the following for detailed instructions for
• 1Fichier (https://rclone.org/fichier/)
• Alias (https://rclone.org/alias/)
• Amazon Drive (https://rclone.org/amazonclouddrive/)
• Amazon S3 (https://rclone.org/s3/)
• Backblaze B2 (https://rclone.org/b2/)
• Box (https://rclone.org/box/)
• Chunker (https://rclone.org/chunker/) - transparently splits large files for other remotes
• Citrix ShareFile (https://rclone.org/sharefile/)
• Compress (https://rclone.org/compress/)
• Crypt (https://rclone.org/crypt/) - to encrypt other remotes
• DigitalOcean Spaces (https://rclone.org/s3/#digitalocean-spaces)
• Dropbox (https://rclone.org/dropbox/)
• Enterprise File Fabric (https://rclone.org/filefabric/)
• FTP (https://rclone.org/ftp/)
• Google Cloud Storage (https://rclone.org/googlecloudstorage/)
• Google Drive (https://rclone.org/drive/)
• Google Photos (https://rclone.org/googlephotos/)
• Hasher (https://rclone.org/hasher/) - to handle checksums for other remotes
• HDFS (https://rclone.org/hdfs/)
• HTTP (https://rclone.org/http/)
• Hubic (https://rclone.org/hubic/)
• Jottacloud (https://rclone.org/jottacloud/)
• Koofr (https://rclone.org/koofr/)
• Mail.ru Cloud (https://rclone.org/mailru/)
• Mega (https://rclone.org/mega/)
• Memory (https://rclone.org/memory/)
• Microsoft Azure Blob Storage (https://rclone.org/azureblob/)
• Microsoft OneDrive (https://rclone.org/onedrive/)
• OpenStack Swift / Rackspace Cloudfiles / Memset Memstore (https://rclone.org/swift/)
• OpenDrive (https://rclone.org/opendrive/)
• Pcloud (https://rclone.org/pcloud/)
• premiumize.me (https://rclone.org/premiumizeme/)
• put.io (https://rclone.org/putio/)
• QingStor (https://rclone.org/qingstor/)
• Seafile (https://rclone.org/seafile/)
• SFTP (https://rclone.org/sftp/)
• Sia (https://rclone.org/sia/)
• SugarSync (https://rclone.org/sugarsync/)
• Tardigrade (https://rclone.org/tardigrade/)
• Union (https://rclone.org/union/)
• Uptobox (https://rclone.org/uptobox/)
• WebDAV (https://rclone.org/webdav/)
• Yandex Disk (https://rclone.org/yandex/)
• Zoho WorkDrive (https://rclone.org/zoho/)
• The local filesystem (https://rclone.org/local/)
Basic syntax Rclone syncs a directory tree from one storage system to another.
Its syntax is like this
Syntax: [options] subcommand <parameters> <parameters...>
Source and destination paths are specified by the name you gave the storage system in the config file then the sub path, e.g. "drive:myfolder" to look at "myfolder" in Google drive.
You can define as many storage paths as you like in the config file.
Please use the -i / --interactive flag while learning rclone to avoid accidental data loss.
Subcommands rclone uses a system of subcommands.  For example
rclone ls remote:path # lists a remote rclone copy /local/path remote:path # copies /local/path to the remote rclone sync -i /local/path remote:path # syncs /local/path to the remote
rclone config Enter an interactive configuration session.
Synopsis Enter an interactive configuration session where you can setup new remotes and manage existing ones.  You may also set or remove a password to protect your configuration.
rclone config [flags]
Options -h, --help   help for config
See the global flags page (https://rclone.org/flags/) for global options not listed here.
SEE ALSO • rclone (https://rclone.org/commands/rclone/) - Show help for rclone commands, flags and backends.
• rclone config create (https://rclone.org/commands/rclone_config_create/) - Create a new remote with name, type and options.
• rclone config delete (https://rclone.org/commands/rclone_config_delete/) - Delete an existing remote.
• rclone config disconnect (https://rclone.org/commands/rclone_config_disconnect/) - Disconnects user from remote
• rclone config dump (https://rclone.org/commands/rclone_config_dump/) - Dump the config file as JSON.
• rclone config file (https://rclone.org/commands/rclone_config_file/) - Show path of configuration file in use.
• rclone config password (https://rclone.org/commands/rclone_config_password/) - Update password in an existing remote.
• rclone config paths (https://rclone.org/commands/rclone_config_paths/) - Show paths used for configuration, cache, temp etc.
• rclone config providers (https://rclone.org/commands/rclone_config_providers/) - List in JSON format all the providers and options.
• rclone config reconnect (https://rclone.org/commands/rclone_config_reconnect/) - Re-authenticates user with remote.
• rclone config show (https://rclone.org/commands/rclone_config_show/) - Print (decrypted) config file, or the config for a single remote.
• rclone config touch (https://rclone.org/commands/rclone_config_touch/) - Ensure configuration file exists.
• rclone config update (https://rclone.org/commands/rclone_config_update/) - Update options in an existing remote.
• rclone config userinfo (https://rclone.org/commands/rclone_config_userinfo/) - Prints info about logged in user of remote.
rclone copy Copy files from source to dest, skipping identical files.
Synopsis Copy the source to the destination.  Does not transfer files that are identical on source and destination, testing by size and modification time or MD5SUM.  Doesn't delete files from the destination.
Note that it is always the contents of the directory that is synced, not the directory so when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents.
If dest:path doesn't exist, it is created and the source:path contents go there.
rclone copy source:sourcepath dest:destpath
Let's say there are two files in sourcepath
sourcepath/one.txt sourcepath/two.txt
This copies them to
destpath/one.txt destpath/two.txt
destpath/sourcepath/one.txt destpath/sourcepath/two.txt
If you are familiar with rsync, rclone always works as if you had written a trailing / - meaning "copy the contents of this directory".  This applies to all commands and whether you are talking about the source or destination.
See the --no-traverse (https://rclone.org/docs/#no-traverse) option for controlling whether rclone lists the destination directory or not. Supplying this option when copying a small number of files into a large destination can speed transfers up greatly.
For example, if you have many files in /path/to/src but only a few of them change every day, you can copy all the files which have changed recently very efficiently like this:
rclone copy --max-age 24h --no-traverse /path/to/src remote:
Note: Use the -P/--progress flag to view real-time transfer statistics.
Note: Use the --dry-run or the --interactive/-i flag to test without copying anything.
rclone copy source:path dest:path [flags]
Options --create-empty-src-dirs   Create empty source dirs on destination after copy -h, --help                    help for copy
rclone sync Make source and dest identical, modifying destination only.
Synopsis Sync the source to the destination, changing the destination only. Doesn't transfer files that are identical on source and destination, testing by size and modification time or MD5SUM.  Destination is updated to match source, including deleting files if necessary (except duplicate objects, see below).
Important: Since this can cause data loss, test first with the --dry-run or the --interactive/-i flag.
rclone sync -i SOURCE remote:DESTINATION
Note that files in the destination won't be deleted if there were any errors at any point.  Duplicate objects (files with the same name, on those providers that support it) are also not yet handled.
It is always the contents of the directory that is synced, not the directory so when source:path is a directory, it's the contents of source:path that are copied, not the directory name and contents.  See extended explanation in the copy command above if unsure.
Note: Use the -P/--progress flag to view real-time transfer statistics
Note: Use the rclone dedupe command to deal with "Duplicate object/directory found in source/destination - ignoring" errors.  See this forum post (https://forum.rclone.org/t/sync-not-clearing- duplicates/14372) for more info.
rclone sync source:path dest:path [flags]
Options --create-empty-src-dirs   Create empty source dirs on destination after sync -h, --help                    help for sync
rclone move Move files from source to dest.
Synopsis Moves the contents of the source directory to the destination directory. Rclone will error if the source and destination overlap and the remote does not support a server-side directory move operation.
If no filters are in use and if possible this will server-side move source:path into dest:path.  After this source:path will no longer exist.
Otherwise for each file in source:path selected by the filters (if any) this will move it into dest:path.  If possible a server-side move will be used, otherwise it will copy it (server-side if possible) into dest:path then delete the original (if no errors on copy) in source:path.
If you want to delete empty source directories after move, use the --delete-empty-src-dirs flag.
See the --no-traverse (https://rclone.org/docs/#no-traverse) option for controlling whether rclone lists the destination directory or not. Supplying this option when moving a small number of files into a large destination can speed transfers up greatly.
rclone move source:path dest:path [flags]
Options --create-empty-src-dirs   Create empty source dirs on destination after move --delete-empty-src-dirs   Delete empty source dirs after move -h, --help                    help for move
rclone delete Remove the files in path.
Synopsis Remove the files in path.  Unlike purge it obeys include/exclude filters so can be used to selectively delete files.
rclone delete only deletes files but leaves the directory structure alone.  If you want to delete a directory and all of its contents use the purge command.
If you supply the --rmdirs flag, it will remove all empty directories along with it.  You can also use the separate command rmdir or rmdirs to delete empty directories only.
For example, to delete all files bigger than 100 MiB, you may first want to check what would be deleted (use either):
rclone --min-size 100M lsl remote:path rclone --dry-run --min-size 100M delete remote:path
Then proceed with the actual delete:
rclone --min-size 100M delete remote:path
That reads "delete everything with a minimum size of 100 MiB", hence delete all files bigger than 100 MiB.
rclone delete remote:path [flags]
Options -h, --help     help for delete --rmdirs   rmdirs removes empty directories but leaves root intact
rclone purge Remove the path and all of its contents.
Synopsis Remove the path and all of its contents.  Note that this does not obey include/exclude filters - everything will be removed.  Use the delete command if you want to selectively delete files.  To delete empty directories only, use command rmdir or rmdirs.
rclone purge remote:path [flags]
Options -h, --help   help for purge
rclone mkdir Make the path if it doesn't already exist.
rclone mkdir remote:path [flags]
Options -h, --help   help for mkdir
rclone rmdir Remove the empty directory at path.
Synopsis This removes empty directory given by path.  Will not remove the path if it has any objects in it, not even empty subdirectories.  Use command rmdirs (or delete with option --rmdirs) to do that.
To delete a path and any objects in it, use purge command.
rclone rmdir remote:path [flags]
Options -h, --help   help for rmdir
rclone check Checks the files in the source and destination match.
Synopsis Checks the files in the source and destination match.  It compares sizes and hashes (MD5 or SHA1) and logs a report of files which don't match. It doesn't alter the source or destination.
If you supply the --size-only flag, it will only compare the sizes not the hashes as well.  Use this for a quick check.
If you supply the --download flag, it will download the data from both remotes and check them against each other on the fly.  This can be useful for remotes that don't support hashes or if you really want to check all the data.
If you supply the --checkfile HASH flag with a valid hash name, the source:path must point to a text file in the SUM format.
If you supply the --one-way flag, it will only check that files in the source match the files in the destination, not the other way around. This means that extra files in the destination that are not in the source will not be detected.
The --differ, --missing-on-dst, --missing-on-src, --match and --error flags write paths, one per line, to the file name (or stdout if it is -) supplied.  What they write is described in the help below.  For example --differ will write all paths which are present on both the source and destination but different.
The --combined flag will write a file (or stdout) which contains all file paths with a symbol and then a space and then the path to tell you what happened to it.  These are reminiscent of diff files.
• = path means path was found in source and destination and was identical
• - path means path was missing on the source, so only in the destination
• + path means path was missing on the destination, so only in the source
• * path means path was present in source and destination but different.
• ! path means there was an error reading or hashing the source or dest.
rclone check source:path dest:path [flags]
Options -C, --checkfile string        Treat source:path as a SUM file with hashes of given type --combined string         Make a combined report of changes to this file --differ string           Report all non-matching files to this file --download                Check by downloading rather than with hash --error string            Report all files with errors (hashing or reading) to this file -h, --help                    help for check --match string            Report all matching files to this file --missing-on-dst string   Report all files missing from the destination to this file --missing-on-src string   Report all files missing from the source to this file --one-way                 Check one way only, source files must exist on remote
rclone ls List the objects in the path with size and path.
Synopsis Lists the objects in the source path to standard output in a human readable format with size and path.  Recurses by default.
$ rclone ls swift:bucket 60295 bevajer5jef 90613 canole 94467 diwogej7 37600 fubuwic
Any of the filtering options can be applied to this command.
There are several related list commands
• ls to list size and path of objects only
• lsl to list modification time, size and path of objects only
• lsd to list directories only
• lsf to list objects and directories in easy to parse format
• lsjson to list objects and directories in JSON format
ls,lsl,lsd are designed to be human readable.  lsf is designed to be human and machine readable.  lsjson is designed to be machine readable.
Note that ls and lsl recurse by default - use --max-depth 1 to stop the recursion.
The other list commands lsd,lsf,lsjson do not recurse by default - use -R to make them recurse.
Listing a non existent directory will produce an error except for remotes which can't have empty directories (e.g.  s3, swift, or gcs - the bucket based remotes).
rclone ls remote:path [flags]
Options -h, --help   help for ls
rclone lsd List all directories/containers/buckets in the path.
Synopsis Lists the directories in the source path to standard output.  Does not recurse by default.  Use the -R flag to recurse.
This command lists the total size of the directory (if known, -1 if not), the modification time (if known, the current time if not), the number of objects in the directory (if known, -1 if not) and the name of the directory, Eg
$ rclone lsd swift: 494000 2018-04-26 08:43:20     10000 10000files 65 2018-04-26 08:43:20         1 1File
$ rclone lsd drive:test -1 2016-10-17 17:41:53        -1 1000files -1 2017-01-03 14:40:54        -1 2500files -1 2017-07-08 14:39:28        -1 4000files
If you just want the directory names use "rclone lsf --dirs-only".
rclone lsd remote:path [flags]
Options -h, --help        help for lsd -R, --recursive   Recurse into the listing
rclone lsl List the objects in path with modification time, size and path.
Synopsis Lists the objects in the source path to standard output in a human readable format with modification time, size and path.  Recurses by default.
$ rclone lsl swift:bucket 60295 2016-06-25 18:55:41.062626927 bevajer5jef 90613 2016-06-25 18:55:43.302607074 canole 94467 2016-06-25 18:55:43.046609333 diwogej7 37600 2016-06-25 18:55:40.814629136 fubuwic
rclone lsl remote:path [flags]
Options -h, --help   help for lsl
rclone md5sum Produces an md5sum file for all the objects in the path.
Synopsis Produces an md5sum file for all the objects in the path.  This is in the same format as the standard md5sum tool produces.
By default, the hash is requested from the remote.  If MD5 is not supported by the remote, no hash will be returned.  With the download flag, the file will be downloaded from the remote and hashed locally enabling MD5 for any remote.
rclone md5sum remote:path [flags]
Options --base64               Output base64 encoded hashsum -C, --checkfile string     Validate hashes against a given SUM file instead of printing them --download             Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help                 help for md5sum --output-file string   Output hashsums to a file rather than the terminal
rclone sha1sum Produces an sha1sum file for all the objects in the path.
Synopsis Produces an sha1sum file for all the objects in the path.  This is in the same format as the standard sha1sum tool produces.
By default, the hash is requested from the remote.  If SHA-1 is not supported by the remote, no hash will be returned.  With the download flag, the file will be downloaded from the remote and hashed locally enabling SHA-1 for any remote.
rclone sha1sum remote:path [flags]
Options --base64               Output base64 encoded hashsum -C, --checkfile string     Validate hashes against a given SUM file instead of printing them --download             Download the file and hash it locally; if this flag is not specified, the hash is requested from the remote -h, --help                 help for sha1sum --output-file string   Output hashsums to a file rather than the terminal
rclone size Prints the total size and number of objects in remote:path.
rclone size remote:path [flags]
Options -h, --help   help for size --json   Format output as JSON
rclone version Show the version number.
Synopsis Show the rclone version number, the go version, the build target OS and architecture, the runtime OS and kernel version and bitness, build tags and the type of executable (static or dynamic).
$ rclone version rclone v1.55.0 - os/version: ubuntu 18.04 (64 bit) - os/kernel: 4.15.0-136-generic (x86_64) - os/type: linux - os/arch: amd64 - go/version: go1.16 - go/linking: static - go/tags: none
Note: before rclone version 1.55 the os/type and os/arch lines were merged, and the "go/version" line was tagged as "go version".
If you supply the --check flag, then it will do an online check to compare your version with the latest release and the latest beta.
$ rclone version --check yours:  1.42.0.6 latest: 1.42          (released 2018-06-16) beta:   1.42.0.5      (released 2018-06-17)
$ rclone version --check yours:  1.41 latest: 1.42          (released 2018-06-16) upgrade: https://downloads.rclone.org/v1.42 beta:   1.42.0.5      (released 2018-06-17) upgrade: https://beta.rclone.org/v1.42-005-g56e1e820
rclone version [flags]
Options --check   Check for new version -h, --help    help for version
rclone cleanup Clean up the remote if possible.
Synopsis Clean up the remote if possible.  Empty the trash or delete old file versions.  Not supported by all remotes.
rclone cleanup remote:path [flags]
Options -h, --help   help for cleanup
rclone dedupe Interactively find duplicate filenames and delete/rename them.
Synopsis By default dedupe interactively finds files with duplicate names and offers to delete all but one or rename them to be different.  This is known as deduping by name.
Deduping by name is only useful with a small group of backends (e.g. Google Drive, Opendrive) that can have duplicate file names.  It can be run on wrapping backends (e.g.  crypt) if they wrap a backend which supports duplicate file names.
However if --by-hash is passed in then dedupe will find files with duplicate hashes instead which will work on any backend which supports at least one hash.  This can be used to find files with duplicate content. This is known as deduping by hash.
If deduping by name, first rclone will merge directories with the same name.  It will do this iteratively until all the identically named directories have been merged.
Next, if deduping by name, for every group of duplicate file names / hashes, it will delete all but one identical files it finds without confirmation.  This means that for most duplicated files the dedupe command will not be interactive.
dedupe considers files to be identical if they have the same file path and the same hash.  If the backend does not support hashes (e.g.  crypt wrapping Google Drive) then they will never be found to be identical.  If you use the --size-only flag then files will be considered identical if they have the same size (any hash will be ignored).  This can be useful on crypt backends which do not support hashes.
Next rclone will resolve the remaining duplicates.  Exactly which action is taken depends on the dedupe mode.  By default rclone will interactively query the user for each one.
Here is an example run.
Before - with duplicates
$ rclone lsl drive:dupes 6048320 2016-03-05 16:23:16.798000000 one.txt 6048320 2016-03-05 16:23:11.775000000 one.txt 564374 2016-03-05 16:23:06.731000000 one.txt 6048320 2016-03-05 16:18:26.092000000 one.txt 6048320 2016-03-05 16:22:46.185000000 two.txt 1744073 2016-03-05 16:22:38.104000000 two.txt 564374 2016-03-05 16:22:52.118000000 two.txt
Now the dedupe session
$ rclone dedupe drive:dupes 2016/03/05 16:24:37 Google drive root 'dupes': Looking for duplicates using interactive mode. one.txt: Found 4 files with duplicate names one.txt: Deleting 2/3 identical duplicates (MD5 "1eedaa9fe86fd4b8632e2ac549403b36") one.txt: 2 duplicates remain 1:      6048320 bytes, 2016-03-05 16:23:16.798000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36 2:       564374 bytes, 2016-03-05 16:23:06.731000000, MD5 7594e7dc9fc28f727c42ee3e0749de81 s) Skip and do nothing k) Keep just one (choose which in next step) r) Rename all to be different (by changing file.jpg to file-1.jpg) s/k/r> k Enter the number of the file to keep> 1 one.txt: Deleted 1 extra copies two.txt: Found 3 files with duplicate names two.txt: 3 duplicates remain 1:       564374 bytes, 2016-03-05 16:22:52.118000000, MD5 7594e7dc9fc28f727c42ee3e0749de81 2:      6048320 bytes, 2016-03-05 16:22:46.185000000, MD5 1eedaa9fe86fd4b8632e2ac549403b36 3:      1744073 bytes, 2016-03-05 16:22:38.104000000, MD5 851957f7fb6f0bc4ce76be966d336802 s) Skip and do nothing k) Keep just one (choose which in next step) r) Rename all to be different (by changing file.jpg to file-1.jpg) s/k/r> r two-1.txt: renamed from: two.txt two-2.txt: renamed from: two.txt two-3.txt: renamed from: two.txt
The result being
$ rclone lsl drive:dupes 6048320 2016-03-05 16:23:16.798000000 one.txt 564374 2016-03-05 16:22:52.118000000 two-1.txt 6048320 2016-03-05 16:22:46.185000000 two-2.txt 1744073 2016-03-05 16:22:38.104000000 two-3.txt
Dedupe can be run non interactively using the --dedupe-mode flag or by using an extra parameter with the same value
• --dedupe-mode interactive - interactive as above.
• --dedupe-mode skip - removes identical files then skips anything left.
• --dedupe-mode first - removes identical files then keeps the first one.
• --dedupe-mode newest - removes identical files then keeps the newest one.
• --dedupe-mode oldest - removes identical files then keeps the oldest one.
• --dedupe-mode largest - removes identical files then keeps the largest one.
• --dedupe-mode smallest - removes identical files then keeps the smallest one.
• --dedupe-mode rename - removes identical files then renames the rest to be different.
• --dedupe-mode list - lists duplicate dirs and files only and changes nothing.
For example to rename all the identically named photos in your Google Photos directory, do
rclone dedupe --dedupe-mode rename "drive:Google Photos"
rclone dedupe rename "drive:Google Photos"
rclone dedupe [mode] remote:path [flags]
Options --by-hash              Find indentical hashes rather than names --dedupe-mode string   Dedupe mode interactive|skip|first|newest|oldest|largest|smallest|rename (default "interactive") -h, --help                 help for dedupe
rclone about Get quota information from the remote.
Synopsis rclone about prints quota information about a remote to standard output. The output is typically used, free, quota and trash contents.
E.g.  Typical output from rclone about remote: is:
Total:   17 GiB Used:    7.444 GiB Free:    1.315 GiB Trashed: 100.000 MiB Other:   8.241 GiB
Where the fields are:
• Total: Total size available.
• Used: Total size used.
• Free: Total space available to this user.
• Trashed: Total space used by trash.
• Other: Total amount in other storage (e.g.  Gmail, Google Photos).
• Objects: Total number of objects in the storage.
All sizes are in number of bytes.
Applying a --full flag to the command prints the bytes in full, e.g.
Total:   18253611008 Used:    7993453766 Free:    1411001220 Trashed: 104857602 Other:   8849156022
A --json flag generates conveniently computer readable output, e.g.
{ "total": 18253611008, "used": 7993453766, "trashed": 104857602, "other": 8849156022, "free": 1411001220 }
Not all backends print all fields.  Information is not included if it is not provided by a backend.  Where the value is unlimited it is omitted.
Some backends does not support the rclone about command at all, see complete list in documentation (https://rclone.org/overview/#optional- features).
rclone about remote: [flags]
Options --full   Full numbers instead of human-readable -h, --help   help for about --json   Format output as JSON
rclone authorize Remote authorization.
Synopsis Remote authorization.  Used to authorize a remote or headless rclone from a machine with a browser - use as instructed by rclone config.
Use the --auth-no-open-browser to prevent rclone to open auth link in default browser automatically.
rclone authorize [flags]
Options --auth-no-open-browser   Do not automatically open auth link in default browser -h, --help                   help for authorize
rclone backend Run a backend specific command.
Synopsis This runs a backend specific command.  The commands themselves (except for "help" and "features") are defined by the backends and you should see the backend docs for definitions.
You can discover what commands a backend implements by using
rclone backend help remote: rclone backend help <backendname>
You can also discover information about the backend using (see operations/fsinfo (https://rclone.org/rc/#operations/fsinfo) in the remote control docs for more info).
rclone backend features remote:
Pass options to the backend command with -o.  This should be key=value or key, e.g.:
rclone backend stats remote:path stats -o format=json -o long
Pass arguments to the backend by placing them on the end of the line
rclone backend cleanup remote:path file1 file2 file3
Note to run these commands on a running backend then see backend/command (https://rclone.org/rc/#backend/command) in the rc docs.
rclone backend <command> remote:path [opts] <args> [flags]
Options -h, --help                 help for backend --json                 Always output in JSON format -o, --option stringArray   Option in the form name=value or name
rclone cat Concatenates any files and sends them to stdout.
Synopsis rclone cat sends any files to standard output.
You can use it like this to output a single file
rclone cat remote:path/to/file
Or like this to output any file in dir or its subdirectories.
rclone cat remote:path/to/dir
Or like this to output any .txt files in dir or its subdirectories.
rclone --include "*.txt" cat remote:path/to/dir
Use the --head flag to print characters only at the start, --tail for the end and --offset and --count to print a section in the middle.  Note that if offset is negative it will count from the end, so --offset -1 --count 1 is equivalent to --tail 1.
rclone cat remote:path [flags]
Options --count int    Only print N characters (default -1) --discard      Discard the output instead of printing --head int     Only print the first N characters -h, --help         help for cat --offset int   Start printing at offset N (or from end if -ve) --tail int     Only print the last N characters
rclone checksum Checks the files in the source against a SUM file.
Synopsis Checks that hashsums of source files match the SUM file.  It compares hashes (MD5, SHA1, etc) and logs a report of files which don't match.  It doesn't alter the file system.
If you supply the --download flag, it will download the data from remote and calculate the contents hash on the fly.  This can be useful for remotes that don't support hashes or if you really want to check all the data.
Note that hash values in the SUM file are treated as case insensitive.
rclone checksum <hash> sumfile src:path [flags]
Options --combined string         Make a combined report of changes to this file --differ string           Report all non-matching files to this file --download                Check by hashing the contents --error string            Report all files with errors (hashing or reading) to this file -h, --help                    help for checksum --match string            Report all matching files to this file --missing-on-dst string   Report all files missing from the destination to this file --missing-on-src string   Report all files missing from the source to this file --one-way                 Check one way only, source files must exist on remote
rclone completion generate the autocompletion script for the specified shell
Synopsis Generate the autocompletion script for rclone for the specified shell. See each sub-command's help for details on how to use the generated script.
Options -h, --help   help for completion
• rclone completion bash (https://rclone.org/commands/rclone_completion_bash/) - generate the autocompletion script for bash
• rclone completion fish (https://rclone.org/commands/rclone_completion_fish/) - generate the autocompletion script for fish
• rclone completion powershell (https://rclone.org/commands/rclone_completion_powershell/) - generate the autocompletion script for powershell
• rclone completion zsh (https://rclone.org/commands/rclone_completion_zsh/) - generate the autocompletion script for zsh
rclone completion bash generate the autocompletion script for bash
Synopsis Generate the autocompletion script for the bash shell.
This script depends on the 'bash-completion' package.  If it is not installed already, you can install it via your OS's package manager.
To load completions in your current shell session: $ source <(rclone completion bash)
To load completions for every new session, execute once: Linux: $ rclone completion bash > /etc/bash_completion.d/rclone MacOS: $ rclone completion bash > /usr/local/etc/bash_completion.d/rclone
You will need to start a new shell for this setup to take effect.
rclone completion bash
Options -h, --help              help for bash --no-descriptions   disable completion descriptions
SEE ALSO • rclone completion (https://rclone.org/commands/rclone_completion/) - generate the autocompletion script for the specified shell
rclone completion fish generate the autocompletion script for fish
Synopsis Generate the autocompletion script for the fish shell.
To load completions in your current shell session: $ rclone completion fish | source
To load completions for every new session, execute once: $ rclone completion fish > ~/.config/fish/completions/rclone.fish
rclone completion fish [flags]
Options -h, --help              help for fish --no-descriptions   disable completion descriptions
rclone completion powershell generate the autocompletion script for powershell
Synopsis Generate the autocompletion script for powershell.
To load completions in your current shell session: PS C:> rclone completion powershell | Out-String | Invoke-Expression
To load completions for every new session, add the output of the above command to your powershell profile.
rclone completion powershell [flags]
Options -h, --help              help for powershell --no-descriptions   disable completion descriptions
rclone completion zsh generate the autocompletion script for zsh
Synopsis Generate the autocompletion script for the zsh shell.
If shell completion is not already enabled in your environment you will need to enable it.  You can execute the following once:
$ echo "autoload -U compinit; compinit" >> ~/.zshrc
To load completions for every new session, execute once: # Linux: $ rclone completion zsh > "${fpath[1]}/_rclone" # macOS: $ rclone completion zsh > /usr/local/share/zsh/site-functions/_rclone
rclone completion zsh [flags]
Options -h, --help              help for zsh --no-descriptions   disable completion descriptions
rclone config create Create a new remote with name, type and options.
Synopsis Create a new remote of name with type and options.  The options should be passed in pairs of key value or as key=value.
For example to make a swift remote of name myremote using auto config you would do:
rclone config create myremote swift env_auth true rclone config create myremote swift env_auth=true
So for example if you wanted to configure a Google Drive remote but using remote authorization you would do this:
rclone config create mydrive drive config_is_local=false
Note that if the config process would normally ask a question the default is taken (unless --non-interactive is used).  Each time that happens rclone will print or DEBUG a message saying how to affect the value taken.
If any of the parameters passed is a password field, then rclone will automatically obscure them if they aren't already obscured before putting them in the config file.
NB If the password parameter is 22 characters or longer and consists only of base64 characters then rclone can get confused about whether the password is already obscured or not and put unobscured passwords into the config file.  If you want to be 100% certain that the passwords get obscured then use the --obscure flag, or if you are 100% certain you are already passing obscured passwords then use --no-obscure.  You can also set obscured passwords using the rclone config password command.
The flag --non-interactive is for use by applications that wish to configure rclone themeselves, rather than using rclone's text based configuration questions.  If this flag is set, and rclone needs to ask the user a question, a JSON blob will be returned with the question in it.
This will look something like (some irrelevant detail removed):
{ "State": "*oauth-islocal,teamdrive,,", "Option": { "Name": "config_is_local", "Help": "Use auto config?\n * Say Y if not sure\n * Say N if you are working on a remote or headless machine\n", "Default": true, "Examples": [ { "Value": "true", "Help": "Yes" }, { "Value": "false", "Help": "No" } ], "Required": false, "IsPassword": false, "Type": "bool", "Exclusive": true, }, "Error": "", }
The format of Option is the same as returned by rclone config providers. The question should be asked to the user and returned to rclone as the --result option along with the --state parameter.
The keys of Option are used as follows:
• Name - name of variable - show to user
• Help - help text.  Hard wrapped at 80 chars.  Any URLs should be clicky.
• Default - default value - return this if the user just wants the default.
• Examples - the user should be able to choose one of these
• Required - the value should be non-empty
• IsPassword - the value is a password and should be edited as such
• Type - type of value, eg bool, string, int and others
• Exclusive - if set no free-form entry allowed only the Examples
• Irrelevant keys Provider, ShortOpt, Hide, NoPrefix, Advanced
If Error is set then it should be shown to the user at the same time as the question.
rclone config update name --continue --state "*oauth-islocal,teamdrive,," --result "true"
Note that when using --continue all passwords should be passed in the clear (not obscured).  Any default config values should be passed in with each invocation of --continue.
At the end of the non interactive process, rclone will return a result with State as empty string.
If --all is passed then rclone will ask all the config questions, not just the post config questions.  Any parameters are used as defaults for questions as usual.
Note that bin/config.py in the rclone source implements this protocol as a readable demonstration.
rclone config create name type [key value]* [flags]
Options --all               Ask the full set of config questions --continue          Continue the configuration process with an answer -h, --help              help for create --no-obscure        Force any passwords not to be obscured --non-interactive   Don't interact with user and return questions --obscure           Force any passwords to be obscured --result string     Result - use with --continue --state string      State - use with --continue
SEE ALSO • rclone config (https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session.
rclone config delete Delete an existing remote.
rclone config delete name [flags]
Options -h, --help   help for delete
rclone config disconnect Disconnects user from remote
Synopsis This disconnects the remote: passed in to the cloud storage system.
This normally means revoking the oauth token.
To reconnect use "rclone config reconnect".
rclone config disconnect remote: [flags]
Options -h, --help   help for disconnect
rclone config dump Dump the config file as JSON.
rclone config dump [flags]
Options -h, --help   help for dump
rclone config edit Enter an interactive configuration session.
rclone config edit [flags]
Options -h, --help   help for edit
• rclone config (https://rclone.org/commands/rclone_config/) - Enter an interactive configuration session.
rclone config file Show path of configuration file in use.
rclone config file [flags]
Options -h, --help   help for file
rclone config password Update password in an existing remote.
Synopsis Update an existing remote's password.  The password should be passed in pairs of key password or as key=password.  The password should be passed in in clear (unobscured).
For example to set password of a remote of name myremote you would do:
rclone config password myremote fieldname mypassword rclone config password myremote fieldname=mypassword
This command is obsolete now that "config update" and "config create" both support obscuring passwords directly.
rclone config password name [key value]+ [flags]
Options -h, --help   help for password
rclone config paths Show paths used for configuration, cache, temp etc.
rclone config paths [flags]
Options -h, --help   help for paths
rclone config providers List in JSON format all the providers and options.
rclone config providers [flags]
Options -h, --help   help for providers
rclone config reconnect Re-authenticates user with remote.
Synopsis This reconnects remote: passed in to the cloud storage system.
To disconnect the remote use "rclone config disconnect".
This normally means going through the interactive oauth flow again.
rclone config reconnect remote: [flags]
Options -h, --help   help for reconnect
rclone config show Print (decrypted) config file, or the config for a single remote.
rclone config show [<remote>] [flags]
Options -h, --help   help for show
rclone config touch Ensure configuration file exists.
rclone config touch [flags]
Options -h, --help   help for touch
rclone config update Update options in an existing remote.
Synopsis Update an existing remote's options.  The options should be passed in pairs of key value or as key=value.
For example to update the env_auth field of a remote of name myremote you would do:
rclone config update myremote env_auth true rclone config update myremote env_auth=true
If the remote uses OAuth the token will be updated, if you don't require this add an extra parameter thus:
rclone config update myremote env_auth=true config_refresh_token=false
rclone config update name [key value]+ [flags]
Options --all               Ask the full set of config questions --continue          Continue the configuration process with an answer -h, --help              help for update --no-obscure        Force any passwords not to be obscured --non-interactive   Don't interact with user and return questions --obscure           Force any passwords to be obscured --result string     Result - use with --continue --state string      State - use with --continue
rclone config userinfo Prints info about logged in user of remote.
Synopsis This prints the details of the person logged in to the cloud storage system.
rclone config userinfo remote: [flags]
Options -h, --help   help for userinfo --json   Format output as JSON
rclone copyto Copy files from source to dest, skipping identical files.
Synopsis If source:path is a file or directory then it copies it to a file or directory named dest:path.