neulab/tldr huggingface dataset:
Which is equivalent to
rclone lsd :s3,env_auth=true:
Note that on the command line you might need to surround these connection strings with " or ' to stop the shell interpreting any special characters within them.
If you are a shell master then you'll know which strings are OK and which aren't, but if you aren't sure then enclose them in " and use ' as the inside quote.  This syntax works on all OSes.
rclone copy ":http,url='https://example.com':path/to/dir" /tmp/dir
On Linux/macOS some characters are still interpreted inside " strings in the shell (notably \ and $ and ") so if your strings contain those you can swap the roles of " and ' thus.  (This syntax does not work on Windows.)
rclone copy ':http,url="https://example.com":path/to/dir' /tmp/dir
Connection strings, config and logging If you supply extra configuration to a backend by command line flag, environment variable or connection string then rclone will add a suffix based on the hash of the config to the name of the remote, eg
rclone -vv lsf --s3-chunk-size 20M s3:
Has the log message
DEBUG : s3: detected overridden config - adding "{Srj1p}" suffix to name
This is so rclone can tell the modified remote apart from the unmodified remote when caching the backends.
This should only be noticeable in the logs.
This means that on the fly backends such as
rclone -vv lsf :s3,env_auth:
Will get their own names
DEBUG : :s3: detected overridden config - adding "{YTu53}" suffix to name
Valid remote names Remote names are case sensitive, and must adhere to the following rules: - May only contain 0-9, A-Z, a-z, _, - and space.  - May not start with - or space.
Quoting and the shell When you are typing commands to your computer you are using something called the command line shell.  This interprets various characters in an OS specific way.
Here are some gotchas which may help users unfamiliar with the shell rules
Linux / OSX If your names have spaces or shell metacharacters (e.g.  *, ?, $, ', ", etc.) then you must quote them.  Use single quotes ' by default.
rclone copy 'Important files?' remote:backup
If you want to send a ' you will need to use ", e.g.
rclone copy "O'Reilly Reviews" remote:backup
The rules for quoting metacharacters are complicated and if you want the full details you'll have to consult the manual page for your shell.
Windows If your names have spaces in you need to put them in ", e.g.
rclone copy "E:\folder name\folder name\folder name" remote:backup
If you are using the root directory on its own then don't quote it (see #464 (https://github.com/rclone/rclone/issues/464) for why), e.g.
rclone copy E:\ remote:backup
Copying files or directories with : in the names rclone uses : to mark a remote name.  This is, however, a valid filename component in non-Windows OSes.  The remote name parser will only search for a : up to the first / so if you need to act on a file or directory like this then use the full path starting with a /, or use ./ as a current directory prefix.
So to sync a directory called sync:me to a remote called remote: use
rclone sync -i ./sync:me remote:path
rclone sync -i /full/path/to/sync:me remote:path
Server Side Copy Most remotes (but not all - see the overview (https://rclone.org/overview/#optional-features)) support server-side copy.
This means if you want to copy one folder to another then rclone won't download all the files and re-upload them; it will instruct the server to copy them in place.
rclone copy s3:oldbucket s3:newbucket
Will copy the contents of oldbucket to newbucket without downloading and re-uploading.
Remotes which don't support server-side copy will download and re-upload in this case.
Server side copies are used with sync and copy and will be identified in the log when using the -v flag.  The move command may also use them if remote doesn't support server-side move directly.  This is done by issuing a server-side copy then a delete which is much quicker than a download and re-upload.
Server side copies will only be attempted if the remote names are the same.
This can be used when scripting to make aged backups efficiently, e.g.
rclone sync -i remote:current-backup remote:previous-backup rclone sync -i /path/to/files remote:current-backup
Options Rclone has a number of options to control its behaviour.
Options that take parameters can have the values passed in two ways, --option=value or --option value.  However boolean (true/false) options behave slightly differently to the other options in that --boolean sets the option to true and the absence of the flag sets it to false.  It is also possible to specify --boolean=false or --boolean=true.  Note that --boolean false is not valid - this is parsed as --boolean and the false is parsed as an extra command line argument for rclone.
Options which use TIME use the go time parser.  A duration string is a possibly signed sequence of decimal numbers, each with optional fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m".  Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
Options which use SIZE use KiB (multiples of 1024 bytes) by default. However, a suffix of B for Byte, K for KiB, M for MiB, G for GiB, T for TiB and P for PiB may be used.  These are the binary units, e.g.  1, 2**10, 2**20, 2**30 respectively.
--backup-dir=DIR When using sync, copy or move any files which would have been overwritten or deleted are moved in their original hierarchy into this directory.
If --suffix is set, then the moved files will have the suffix added to them.  If there is a file with the same path (after the suffix has been added) in DIR, then it will be overwritten.
The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync.  The backup directory must not overlap the destination directory.
rclone sync -i /path/to/local remote:current --backup-dir remote:old
will sync /path/to/local to remote:current, but for any files which would have been updated or deleted will be stored in remote:old.
If running rclone from a script you might want to use today's date as the directory name passed to --backup-dir to store the old files, or you might want to pass --suffix with today's date.
See --compare-dest and --copy-dest.
--bind string Local address to bind to for outgoing connections.  This can be an IPv4 address (1.2.3.4), an IPv6 address (1234::789A) or host name.  If the host name doesn't resolve or resolves to more than one IP address it will give an error.
--bwlimit=BANDWIDTH_SPEC This option controls the bandwidth limit.  For example
--bwlimit 10M
would mean limit the upload and download bandwidth to 10 MiB/s.  NB this is bytes per second not bits per second.  To use a single limit, specify the desired bandwidth in KiB/s, or use a suffix B|K|M|G|T|P.  The default is 0 which means to not limit bandwidth.
The upload and download bandwidth can be specified seperately, as --bwlimit UP:DOWN, so
--bwlimit 10M:100k
would mean limit the upload bandwidth to 10 MiB/s and the download bandwidth to 100 KiB/s.  Either limit can be "off" meaning no limit, so to just limit the upload bandwidth you would use
--bwlimit 10M:off
this would limit the upload bandwidth to 10 MiB/s but the download bandwidth would be unlimited.
When specified as above the bandwidth limits last for the duration of run of the rclone binary.
It is also possible to specify a "timetable" of limits, which will cause certain limits to be applied at certain times.  To specify a timetable, format your entries as WEEKDAY-HH:MM,BANDWIDTH WEEKDAY-HH:MM,BANDWIDTH... where: WEEKDAY is optional element.
• BANDWIDTH can be a single number, e.g.100k or a pair of numbers for upload:download, e.g.10M:1M.
• WEEKDAY can be written as the whole word or only using the first 3 characters.  It is optional.
• HH:MM is an hour from 00:00 to 23:59.
An example of a typical timetable to avoid link saturation during daytime working hours could be:
--bwlimit "08:00,512k 12:00,10M 13:00,512k 18:00,30M 23:00,off"
In this example, the transfer bandwidth will be set to 512 KiB/s at 8am every day.  At noon, it will rise to 10 MiB/s, and drop back to 512 KiB/sec at 1pm.  At 6pm, the bandwidth limit will be set to 30 MiB/s, and at 11pm it will be completely disabled (full speed).  Anything between 11pm and 8am will remain unlimited.
An example of timetable with WEEKDAY could be:
--bwlimit "Mon-00:00,512 Fri-23:59,10M Sat-10:00,1M Sun-20:00,off"
It means that, the transfer bandwidth will be set to 512 KiB/s on Monday. It will rise to 10 MiB/s before the end of Friday.  At 10:00 on Saturday it will be set to 1 MiB/s.  From 20:00 on Sunday it will be unlimited.
Timeslots without WEEKDAY are extended to the whole week.  So this example:
--bwlimit "Mon-00:00,512 12:00,1M Sun-20:00,off"
Is equivalent to this:
--bwlimit "Mon-00:00,512Mon-12:00,1M Tue-12:00,1M Wed-12:00,1M Thu-12:00,1M Fri-12:00,1M Sat-12:00,1M Sun-12:00,1M Sun-20:00,off"
Bandwidth limit apply to the data transfer for all backends.  For most backends the directory listing bandwidth is also included (exceptions being the non HTTP backends, ftp, sftp and tardigrade).
Note that the units are Byte/s, not bit/s.  Typically connections are measured in bit/s - to convert divide by 8.  For example, let's say you have a 10 Mbit/s connection and you wish rclone to use half of it - 5 Mbit/s.  This is 5/8 = 0.625 MiB/s so you would use a --bwlimit 0.625M parameter for rclone.
On Unix systems (Linux, macOS, ...) the bandwidth limiter can be toggled by sending a SIGUSR2 signal to rclone.  This allows to remove the limitations of a long running rclone transfer and to restore it back to the value specified with --bwlimit quickly when needed.  Assuming there is only one rclone instance running, you can toggle the limiter like this:
kill -SIGUSR2 $(pidof rclone)
If you configure rclone with a remote control (/rc) then you can use change the bwlimit dynamically:
rclone rc core/bwlimit rate=1M
--bwlimit-file=BANDWIDTH_SPEC This option controls per file bandwidth limit.  For the options see the --bwlimit flag.
For example use this to allow no transfers to be faster than 1 MiB/s
--bwlimit-file 1M
This can be used in conjunction with --bwlimit.
Note that if a schedule is provided the file will use the schedule in effect at the start of the transfer.
--buffer-size=SIZE Use this sized buffer to speed up file transfers.  Each --transfer will use this much memory for buffering.
When using mount or cmount each open file descriptor will use this much memory for buffering.  See the mount (https://rclone.org/commands/rclone_mount/#file-buffering) documentation for more details.
Set to 0 to disable the buffering for the minimum memory usage.
Note that the memory allocation of the buffers is influenced by the --use-mmap flag.
--cache-dir=DIR Specify the directory rclone will use for caching, to override the default.
Default value is depending on operating system: - Windows %LocalAppData%\rclone, if LocalAppData is defined.  - macOS $HOME/Library/Caches/rclone if HOME is defined.  - Unix $XDG_CACHE_HOME/rclone if XDG_CACHE_HOME is defined, else $HOME/.cache/rclone if HOME is defined.  - Fallback (on all OS) to $TMPDIR/rclone, where TMPDIR is the value from --temp-dir.
You can use the config paths (https://rclone.org/commands/rclone_config_paths/) command to see the current value.
Cache directory is heavily used by the VFS File Caching (https://rclone.org/commands/rclone_mount/#vfs-file-caching) mount feature, but also by serve (https://rclone.org/commands/rclone_serve/), GUI (/gui) and other parts of rclone.
--check-first If this flag is set then in a sync, copy or move, rclone will do all the checks to see whether files need to be transferred before doing any of the transfers.  Normally rclone would start running transfers as soon as possible.
This flag can be useful on IO limited systems where transfers interfere with checking.
It can also be useful to ensure perfect ordering when using --order-by.
Using this flag can use more memory as it effectively sets --max-backlog to infinite.  This means that all the info on the objects to transfer is held in memory before the transfers start.
--checkers=N The number of checkers to run in parallel.  Checkers do the equality checking of files during a sync.  For some storage systems (e.g.  S3, Swift, Dropbox) this can take a significant amount of time so they are run in parallel.
The default is to run 8 checkers in parallel.
-c, --checksum Normally rclone will look at modification time and size of files to see if they are equal.  If you set this flag then rclone will check the file hash and size to determine if files are equal.
This is useful when the remote doesn't support setting modified time and a more accurate sync is desired than just checking the file size.
This is very useful when transferring between remotes which store the same hash type on the object, e.g.  Drive and Swift.  For details of which remotes support which hash type see the table in the overview section (https://rclone.org/overview/).
Eg rclone --checksum sync s3:/bucket swift:/bucket would run much quicker than without the --checksum flag.
When using this flag, rclone won't update mtimes of remote files if they are incorrect as it would normally.
--compare-dest=DIR When using sync, copy or move DIR is checked in addition to the destination for files.  If a file identical to the source is found that file is NOT copied from source.  This is useful to copy just files that have changed since the last backup.
You must use the same remote as the destination of the sync.  The compare directory must not overlap the destination directory.
See --copy-dest and --backup-dir.
--config=CONFIG_FILE Specify the location of the rclone configuration file, to override the default.  E.g.  rclone config --config="rclone.conf".
The exact default is a bit complex to describe, due to changes introduced through different versions of rclone while preserving backwards compatibility, but in most cases it is as simple as:
• %APPDATA%/rclone/rclone.conf on Windows
• ~/.config/rclone/rclone.conf on other
The complete logic is as follows: Rclone will look for an existing configuration file in any of the following locations, in priority order:
1. rclone.conf (in program directory, where rclone executable is)
2. %APPDATA%/rclone/rclone.conf (only on Windows)
3. $XDG_CONFIG_HOME/rclone/rclone.conf (on all systems, including Windows)
4. ~/.config/rclone/rclone.conf (see below for explanation of ~ symbol)
5. ~/.rclone.conf
If no existing configuration file is found, then a new one will be created in the following location:
• On Windows: Location 2 listed above, except in the unlikely event that APPDATA is not defined, then location 4 is used instead.
• On Unix: Location 3 if XDG_CONFIG_HOME is defined, else location 4.
• Fallback to location 5 (on all OS), when the rclone directory cannot be created, but if also a home directory was not found then path .rclone.conf relative to current working directory will be used as a final resort.
The ~ symbol in paths above represent the home directory of the current user on any OS, and the value is defined as following:
• On Windows: %HOME% if defined, else %USERPROFILE%, or else %HOMEDRIVE%\%HOMEPATH%.
• On Unix: $HOME if defined, else by looking up current user in OS-specific user database (e.g.  passwd file), or else use the result from shell command cd && pwd.
If you run rclone config file you will see where the default location is for you.
The fact that an existing file rclone.conf in the same directory as the rclone executable is always preferred, means that it is easy to run in "portable" mode by downloading rclone executable to a writable directory and then create an empty file rclone.conf in the same directory.
If the location is set to empty string "" or path to a file with name notfound, or the os null device represented by value NUL on Windows and /dev/null on Unix systems, then rclone will keep the config file in memory only.
The file format is basic INI (https://en.wikipedia.org/wiki/INI_file#Format): Sections of text, led by a [section] header and followed by key=value entries on separate lines. In rclone each remote is represented by its own section, where the section name defines the name of the remote.  Options are specified as the key=value entries, where the key is the option name without the --backend- prefix, in lowercase and with _ instead of -.  E.g.  option --mega-hard-delete corresponds to key hard_delete.  Only backend options can be specified.  A special, and required, key type identifies the storage system (https://rclone.org/overview/), where the value is the internal lowercase name as returned by command rclone help backends. Comments are indicated by ; or # at the beginning of a line.
[megaremote] type = mega user = you@example.com pass = PDPcQVVjVtzFY-GTdDFozqBhTdsPg3qH
Note that passwords are in obscured (https://rclone.org/commands/rclone_obscure/) form.  Also, many storage systems uses token-based authentication instead of passwords, and this requires additional steps.  It is easier, and safer, to use the interactive command rclone config instead of manually editing the configuration file.
The configuration file will typically contain login information, and should therefore have restricted permissions so that only the current user can read it.  Rclone tries to ensure this when it writes the file. You may also choose to encrypt the file.
When token-based authentication are used, the configuration file must be writable, because rclone needs to update the tokens inside it.
--contimeout=TIME Set the connection timeout.  This should be in go time format which looks like 5s for 5 seconds, 10m for 10 minutes, or 3h30m.
The connection timeout is the amount of time rclone will wait for a connection to go through to a remote object storage system.  It is 1m by default.
--copy-dest=DIR When using sync, copy or move DIR is checked in addition to the destination for files.  If a file identical to the source is found that file is server-side copied from DIR to the destination.  This is useful for incremental backup.
The remote in use must support server-side copy and you must use the same remote as the destination of the sync.  The compare directory must not overlap the destination directory.
See --compare-dest and --backup-dir.
--dedupe-mode MODE Mode to run dedupe command in.  One of interactive, skip, first, newest, oldest, rename.  The default is interactive.  See the dedupe command for more information as to what these options mean.
--disable FEATURE,FEATURE,... This disables a comma separated list of optional features.  For example to disable server-side move and server-side copy use:
--disable move,copy
The features can be put in any case.
To see a list of which features can be disabled use:
--disable help
See the overview features (https://rclone.org/overview/#features) and optional features (https://rclone.org/overview/#optional-features) to get an idea of which feature does what.
This flag can be useful for debugging and in exceptional circumstances (e.g.  Google Drive limiting the total volume of Server Side Copies to 100 GiB/day).
--dscp VALUE Specify a DSCP value or name to use in connections.  This could help QoS system to identify traffic class.  BE, EF, DF, LE, CSx and AFxx are allowed.
See the description of differentiated services (https://en.wikipedia.org/wiki/Differentiated_services) to get an idea of this field.  Setting this to 1 (LE) to identify the flow to SCAVENGER class can avoid occupying too much bandwidth in a network with DiffServ support (RFC 8622 (https://tools.ietf.org/html/rfc8622)).
For example, if you configured QoS on router to handle LE properly. Running:
rclone copy --dscp LE from:/from to:/to
would make the priority lower than usual internet flows.
This option has no effect on Windows (see golang/go#42728 (https://github.com/golang/go/issues/42728)).
-n, --dry-run Do a trial run with no permanent changes.  Use this to see what rclone would do without actually doing it.  Useful when setting up the sync command which deletes files in the destination.
--expect-continue-timeout=TIME This specifies the amount of time to wait for a server's first response headers after fully writing the request headers if the request has an "Expect: 100-continue" header.  Not all backends support using this.
Zero means no timeout and causes the body to be sent immediately, without waiting for the server to approve.  This time does not include the time to send the request header.
The default is 1s.  Set to 0 to disable.
--error-on-no-transfer By default, rclone will exit with return code 0 if there were no errors.
This option allows rclone to return exit code 9 if no files were transferred between the source and destination.  This allows using rclone in scripts, and triggering follow-on actions if data was copied, or skipping if not.
NB: Enabling this option turns a usually non-fatal error into a potentially fatal one - please check and adjust your scripts accordingly!
--fs-cache-expire-duration=TIME When using rclone via the API rclone caches created remotes for 5 minutes by default in the "fs cache".  This means that if you do repeated actions on the same remote then rclone won't have to build it again from scratch, which makes it more efficient.
This flag sets the time that the remotes are cached for.  If you set it to 0 (or negative) then rclone won't cache the remotes at all.
Note that if you use some flags, eg --backup-dir and if this is set to 0 rclone may build two remotes (one for the source or destination and one for the --backup-dir where it may have only built one before.
--fs-cache-expire-interval=TIME This controls how often rclone checks for cached remotes to expire.  See the --fs-cache-expire-duration documentation above for more info.  The default is 60s, set to 0 to disable expiry.
--header Add an HTTP header for all transactions.  The flag can be repeated to add multiple headers.
If you want to add headers only for uploads use --header-upload and if you want to add headers only for downloads use --header-download.
This flag is supported for all HTTP based backends even those not supported by --header-upload and --header-download so may be used as a workaround for those with care.
rclone ls remote:test --header "X-Rclone: Foo" --header "X-LetMeIn: Yes"
--header-download Add an HTTP header for all download transactions.  The flag can be repeated to add multiple headers.
rclone sync -i s3:test/src ~/dst --header-download "X-Amz-Meta-Test: Foo" --header-download "X-Amz-Meta-Test2: Bar"
See the GitHub issue here (https://github.com/rclone/rclone/issues/59) for currently supported backends.
--header-upload Add an HTTP header for all upload transactions.  The flag can be repeated to add multiple headers.
rclone sync -i ~/src s3:test/dst --header-upload "Content-Disposition: attachment; filename='cool.html'" --header-upload "X-Amz-Meta-Test: FooBar"
--human-readable Rclone commands output values for sizes (e.g.  number of bytes) and counts (e.g.  number of files) either as raw numbers, or in human-readable format.
In human-readable format the values are scaled to larger units, indicated with a suffix shown after the value, and rounded to three decimals. Rclone consistently uses binary units (powers of 2) for sizes and decimal units (powers of 10) for counts.  The unit prefix for size is according to IEC standard notation, e.g.  Ki for kibi.  Used with byte unit, 1 KiB means 1024 Byte.  In list type of output, only the unit prefix appended to the value (e.g.  9.762Ki), while in more textual output the full unit is shown (e.g.  9.762 KiB).  For counts the SI standard notation is used, e.g.  prefix k for kilo.  Used with file counts, 1k means 1000 files.
The various list (commands/rclone_ls/) commands output raw numbers by default.  Option --human-readable will make them output values in human-readable format instead (with the short unit prefix).
The about (commands/rclone_about/) command outputs human-readable by default, with a command-specific option --full to output the raw numbers instead.
Command size (commands/rclone_size/) outputs both human-readable and raw numbers in the same output.
The tree (commands/rclone_tree/) command also considers --human-readable, but it will not use the exact same notation as the other commands: It rounds to one decimal, and uses single letter suffix, e.g.  K instead of Ki.  The reason for this is that it relies on an external library.
The interactive command ncdu (commands/rclone_ncdu/) shows human-readable by default, and responds to key u for toggling human-readable format.
--ignore-case-sync Using this option will cause rclone to ignore the case of the files when synchronizing so files will not be copied/synced when the existing filenames are the same, even if the casing is different.
--ignore-checksum Normally rclone will check that the checksums of transferred files match, and give an error "corrupted on transfer" if they don't.
You can use this option to skip that check.  You should only use it if you have had the "corrupted on transfer" error message and you are sure you might want to transfer potentially corrupted data.
--ignore-existing Using this option will make rclone unconditionally skip all files that exist on the destination, no matter the content of these files.
While this isn't a generally recommended option, it can be useful in cases where your files change due to encryption.  However, it cannot correct partial transfers in case a transfer was interrupted.
When performing a move/moveto command, this flag will leave skipped files in the source location unchanged when a file with the same name exists on the destination.
--ignore-size Normally rclone will look at modification time and size of files to see if they are equal.  If you set this flag then rclone will check only the modification time.  If --checksum is set then it only checks the checksum.
It will also cause rclone to skip verifying the sizes are the same after transfer.
This can be useful for transferring files to and from OneDrive which occasionally misreports the size of image files (see #399 (https://github.com/rclone/rclone/issues/399) for more info).
-I, --ignore-times Using this option will cause rclone to unconditionally upload all files regardless of the state of files on the destination.
Normally rclone would skip any files that have the same modification time and are the same size (or have the same checksum if using --checksum).
--immutable Treat source and destination files as immutable and disallow modification.
With this option set, files will be created and deleted as requested, but existing files will never be updated.  If an existing file does not match between the source and destination, rclone will give the error Source and destination exist but do not match: immutable file modified.
Note that only commands which transfer files (e.g.  sync, copy, move) are affected by this behavior, and only modification is disallowed.  Files may still be deleted explicitly (e.g.  delete, purge) or implicitly (e.g. sync, move).  Use copy --immutable if it is desired to avoid deletion as well as modification.
This can be useful as an additional layer of protection for immutable or append-only data sets (notably backup archives), where modification implies corruption and should not be propagated.
-i / --interactive This flag can be used to tell rclone that you wish a manual confirmation before destructive operations.
It is recommended that you use this flag while learning rclone especially with rclone sync.
$ rclone delete -i /tmp/dir rclone: delete "important-file.txt"? y) Yes, this is OK (default) n) No, skip this s) Skip all delete operations with no more questions !) Do all delete operations with no more questions q) Exit rclone now. y/n/s/!/q> n
The options mean
• y: Yes, this operation should go ahead.  You can also press Return for this to happen.  You'll be asked every time unless you choose s or !.
• n: No, do not do this operation.  You'll be asked every time unless you choose s or !.
• s: Skip all the following operations of this type with no more questions.  This takes effect until rclone exits.  If there are any different kind of operations you'll be prompted for them.
• !: Do all the following operations with no more questions.  Useful if you've decided that you don't mind rclone doing that kind of operation. This takes effect until rclone exits .  If there are any different kind of operations you'll be prompted for them.
• q: Quit rclone now, just in case!
--leave-root During rmdirs it will not remove root directory, even if it's empty.
--log-file=FILE Log all of rclone's output to FILE.  This is not active by default.  This can be useful for tracking down problems with syncs in combination with the -v flag.  See the Logging section for more info.
If FILE exists then rclone will append to it.
Note that if you are using the logrotate program to manage rclone's logs, then you should use the copytruncate option as rclone doesn't have a signal to rotate logs.
--log-format LIST Comma separated list of log format options.  Accepted options are date, time, microseconds, pid, longfile, shortfile, UTC.  Any other keywords will be silently ignored.  pid will tag log messages with process identifier which useful with rclone mount --daemon.  Other accepted options are explained in the go documentation (https://pkg.go.dev/log#pkg-constants).  The default log format is "date,time".
--log-level LEVEL This sets the log level for rclone.  The default log level is NOTICE.
DEBUG is equivalent to -vv.  It outputs lots of debug info - useful for bug reports and really finding out what rclone is doing.
INFO is equivalent to -v.  It outputs information about each transfer and prints stats once a minute by default.
NOTICE is the default log level if no logging flags are supplied.  It outputs very little when things are working normally.  It outputs warnings and significant events.
ERROR is equivalent to -q.  It only outputs error messages.
--use-json-log This switches the log format to JSON for rclone.  The fields of json log are level, msg, source, time.
--low-level-retries NUMBER This controls the number of low level retries rclone does.
A low level retry is used to retry a failing operation - typically one HTTP request.  This might be uploading a chunk of a big file for example. You will see low level retries in the log with the -v flag.
This shouldn't need to be changed from the default in normal operations. However, if you get a lot of low level retries you may wish to reduce the value so rclone moves on to a high level retry (see the --retries flag) quicker.
Disable low level retries with --low-level-retries 1.
--max-backlog=N This is the maximum allowable backlog of files in a sync/copy/move queued for being checked or transferred.
This can be set arbitrarily large.  It will only use memory when the queue is in use.  Note that it will use in the order of N KiB of memory when the backlog is in use.
Setting this large allows rclone to calculate how many files are pending more accurately, give a more accurate estimated finish time and make --order-by work more accurately.
Setting this small will make rclone more synchronous to the listings of the remote which may be desirable.
Setting this to a negative number will make the backlog as large as possible.
--max-delete=N This tells rclone not to delete more than N files.  If that limit is exceeded then a fatal error will be generated and rclone will stop the operation in progress.
--max-depth=N This modifies the recursion depth for all the commands except purge.
So if you do rclone --max-depth 1 ls remote:path you will see only the files in the top level directory.  Using --max-depth 2 means you will see all the files in first two directory levels and so on.
For historical reasons the lsd command defaults to using a --max-depth of 1 - you can override this with the command line flag.
You can use this command to disable recursion (with --max-depth 1).
Note that if you use this with sync and --delete-excluded the files not recursed through are considered excluded and will be deleted on the destination.  Test first with --dry-run if you are not sure what will happen.
--max-duration=TIME Rclone will stop scheduling new transfers when it has run for the duration specified.
Defaults to off.
When the limit is reached any existing transfers will complete.
Rclone won't exit with an error if the transfer limit is reached.
--max-transfer=SIZE Rclone will stop transferring when it has reached the size specified. Defaults to off.
When the limit is reached all transfers will stop immediately.
Rclone will exit with exit code 8 if the transfer limit is reached.
--cutoff-mode=hard|soft|cautious This modifies the behavior of --max-transfer Defaults to --cutoff-mode=hard.
Specifying --cutoff-mode=hard will stop transferring immediately when Rclone reaches the limit.
Specifying --cutoff-mode=soft will stop starting new transfers when Rclone reaches the limit.
Specifying --cutoff-mode=cautious will try to prevent Rclone from reaching the limit.
--modify-window=TIME When checking whether a file has been modified, this is the maximum allowed time difference that a file can have and still be considered equivalent.
The default is 1ns unless this is overridden by a remote.  For example OS X only stores modification times to the nearest second so if you are reading and writing to an OS X filing system this will be 1s by default.
This command line flag allows you to override that computed default.
--multi-thread-cutoff=SIZE When downloading files to the local backend above this size, rclone will use multiple threads to download the file (default 250M).
Rclone preallocates the file (using fallocate(FALLOC_FL_KEEP_SIZE) on unix or NTSetInformationFile on Windows both of which takes no time) then each thread writes directly into the file at the correct place.  This means that rclone won't create fragmented or sparse files and there won't be any assembly time at the end of the transfer.
The number of threads used to download is controlled by --multi-thread-streams.
Use -vv if you wish to see info about the threads.
This will work with the sync/copy/move commands and friends copyto/moveto.  Multi thread downloads will be used with rclone mount and rclone serve if --vfs-cache-mode is set to writes or above.
NB that this only works for a local destination but will work with any source.
NB that multi thread copies are disabled for local to local copies as they are faster without unless --multi-thread-streams is set explicitly.
NB on Windows using multi-thread downloads will cause the resulting files to be sparse (https://en.wikipedia.org/wiki/Sparse_file).  Use --local-no-sparse to disable sparse files (which may cause long delays at the start of downloads) or disable multi-thread downloads with --multi-thread-streams 0
--multi-thread-streams=N When using multi thread downloads (see above --multi-thread-cutoff) this sets the maximum number of streams to use.  Set to 0 to disable multi thread downloads (Default 4).
Exactly how many streams rclone uses for the download depends on the size of the file.  To calculate the number of download streams Rclone divides the size of the file by the --multi-thread-cutoff and rounds up, up to the maximum set with --multi-thread-streams.
So if --multi-thread-cutoff 250M and --multi-thread-streams 4 are in effect (the defaults):
• 0..250 MiB files will be downloaded with 1 stream
• 250..500 MiB files will be downloaded with 2 streams
• 500..750 MiB files will be downloaded with 3 streams
• 750+ MiB files will be downloaded with 4 streams
--no-check-dest The --no-check-dest can be used with move or copy and it causes rclone not to check the destination at all when copying files.
• the destination is not listed minimising the API calls
• files are always transferred
• this can cause duplicates on remotes which allow it (e.g.  Google Drive)
• --retries 1 is recommended otherwise you'll transfer everything again on a retry
This flag is useful to minimise the transactions if you know that none of the files are on the destination.
This is a specialized flag which should be ignored by most users!
--no-gzip-encoding Don't set Accept-Encoding: gzip.  This means that rclone won't ask the server for compressed files automatically.  Useful if you've set the server to return files with Content-Encoding: gzip but you uploaded compressed files.
There is no need to set this in normal operation, and doing so will decrease the network transfer efficiency of rclone.
--no-traverse The --no-traverse flag controls whether the destination file system is traversed when using the copy or move commands.  --no-traverse is not compatible with sync and will be ignored if you supply it with sync.
If you are only copying a small number of files (or are filtering most of the files) and/or have a large number of files on the destination then --no-traverse will stop rclone listing the destination and save time.
However, if you are copying a large number of files, especially if you are doing a copy where lots of the files under consideration haven't changed and won't need copying then you shouldn't use --no-traverse.
See rclone copy (https://rclone.org/commands/rclone_copy/) for an example of how to use it.
--no-unicode-normalization Don't normalize unicode characters in filenames during the sync routine.
Sometimes, an operating system will store filenames containing unicode parts in their decomposed form (particularly macOS).  Some cloud storage systems will then recompose the unicode, resulting in duplicate files if the data is ever copied back to a local filesystem.
Using this flag will disable that functionality, treating each unicode character as unique.  For example, by default é and é will be normalized into the same character.  With --no-unicode-normalization they will be treated as unique characters.
--no-update-modtime When using this flag, rclone won't update modification times of remote files if they are incorrect as it would normally.
This can be used if the remote is being synced with another tool also (e.g.  the Google Drive client).
--order-by string The --order-by flag controls the order in which files in the backlog are processed in rclone sync, rclone copy and rclone move.
The order by string is constructed like this.  The first part describes what aspect is being measured:
• size - order by the size of the files
• name - order by the full path of the files
• modtime - order by the modification date of the files
This can have a modifier appended with a comma:
• ascending or asc - order so that the smallest (or oldest) is processed first
• descending or desc - order so that the largest (or newest) is processed first
• mixed - order so that the smallest is processed first for some threads and the largest for others
If the modifier is mixed then it can have an optional percentage (which defaults to 50), e.g.  size,mixed,25 which means that 25% of the threads should be taking the smallest items and 75% the largest.  The threads which take the smallest first will always take the smallest first and likewise the largest first threads.  The mixed mode can be useful to minimise the transfer time when you are transferring a mixture of large and small files - the large files are guaranteed upload threads and bandwidth and the small files will be processed continuously.
If no modifier is supplied then the order is ascending.
• --order-by size,desc - send the largest files first
• --order-by modtime,ascending - send the oldest files first
• --order-by name - send the files with alphabetically by path first
If the --order-by flag is not supplied or it is supplied with an empty string then the default ordering will be used which is as scanned.  With --checkers 1 this is mostly alphabetical, however with the default --checkers 8 it is somewhat random.
Limitations The --order-by flag does not do a separate pass over the data.  This means that it may transfer some files out of the order specified if
• there are no files in the backlog or the source has not been fully scanned yet
• there are more than --max-backlog files in the backlog
Rclone will do its best to transfer the best file it has so in practice this should not cause a problem.  Think of --order-by as being more of a best efforts flag rather than a perfect ordering.
If you want perfect ordering then you will need to specify --check-first which will find all the files which need transferring first before transferring any.
--password-command SpaceSepList This flag supplies a program which should supply the config password when run.  This is an alternative to rclone prompting for the password or setting the RCLONE_CONFIG_PASS variable.
The argument to this should be a command with a space separated list of arguments.  If one of the arguments has a space in then enclose it in ", if you want a literal " in an argument then enclose the argument in " and double the ".  See CSV encoding (https://godoc.org/encoding/csv) for more info.
--password-command echo hello --password-command echo "hello with space" --password-command echo "hello with ""quotes"" and space"
See the Configuration Encryption for more info.
See a Windows PowerShell example on the Wiki (https://github.com/rclone/rclone/wiki/Windows-Powershell-use-rclone- password-command-for-Config-file-password).
-P, --progress This flag makes rclone update the stats in a static block in the terminal providing a realtime overview of the transfer.
Any log messages will scroll above the static block.  Log messages will push the static block down to the bottom of the terminal where it will stay.
Normally this is updated every 500mS but this period can be overridden with the --stats flag.
This can be used with the --stats-one-line flag for a simpler display.
Note: On Windows until this bug (https://github.com/Azure/go- ansiterm/issues/26) is fixed all non-ASCII characters will be replaced with . when --progress is in use.
--progress-terminal-title This flag, when used with -P/--progress, will print the string ETA: %s to the terminal title.
-q, --quiet This flag will limit rclone's output to error messages only.
--refresh-times The --refresh-times flag can be used to update modification times of existing files when they are out of sync on backends which don't support hashes.
This is useful if you uploaded files with the incorrect timestamps and you now wish to correct them.
This flag is only useful for destinations which don't support hashes (e.g.  crypt).
This can be used any of the sync commands sync, copy or move.
To use this flag you will need to be doing a modification time sync (so not using --size-only or --checksum).  The flag will have no effect when using --size-only or --checksum.
If this flag is used when rclone comes to upload a file it will check to see if there is an existing file on the destination.  If this file matches the source with size (and checksum if available) but has a differing timestamp then instead of re-uploading it, rclone will update the timestamp on the destination file.  If the checksum does not match rclone will upload the new file.  If the checksum is absent (e.g.  on a crypt backend) then rclone will update the timestamp.
Note that some remotes can't set the modification time without re-uploading the file so this flag is less useful on them.
Normally if you are doing a modification time sync rclone will update modification times without --refresh-times provided that the remote supports checksums and the checksums match on the file.  However if the checksums are absent then rclone will upload the file rather than setting the timestamp as this is the safe behaviour.
--retries int Retry the entire sync if it fails this many times it fails (default 3).
Some remotes can be unreliable and a few retries help pick up the files which didn't get transferred because of errors.
Disable retries with --retries 1.
--retries-sleep=TIME This sets the interval between each retry specified by --retries
The default is 0.  Use 0 to disable.
--size-only Normally rclone will look at modification time and size of files to see if they are equal.  If you set this flag then rclone will check only the size.
This can be useful transferring files from Dropbox which have been modified by the desktop sync client which doesn't set checksums of modification times in the same way as rclone.
--stats=TIME Commands which transfer data (sync, copy, copyto, move, moveto) will print data transfer stats at regular intervals to show their progress.
This sets the interval.
The default is 1m.  Use 0 to disable.
If you set the stats interval then all commands can show stats.  This can be useful when running other commands, check or mount for example.
Stats are logged at INFO level by default which means they won't show at default log level NOTICE.  Use --stats-log-level NOTICE or -v to make them show.  See the Logging section for more info on log levels.
Note that on macOS you can send a SIGINFO (which is normally ctrl-T in the terminal) to make the stats print immediately.
--stats-file-name-length integer By default, the --stats output will truncate file names and paths longer than 40 characters.  This is equivalent to providing --stats-file-name-length 40.  Use --stats-file-name-length 0 to disable any truncation of file names printed by stats.
--stats-log-level string Log level to show --stats output at.  This can be DEBUG, INFO, NOTICE, or ERROR.  The default is INFO.  This means at the default level of logging which is NOTICE the stats won't show - if you want them to then use --stats-log-level NOTICE.  See the Logging section for more info on log levels.
--stats-one-line When this is specified, rclone condenses the stats into a single line showing the most important stats only.
--stats-one-line-date When this is specified, rclone enables the single-line stats and prepends the display with a date string.  The default is 2006/01/02 15:04:05 -
--stats-one-line-date-format When this is specified, rclone enables the single-line stats and prepends the display with a user-supplied date string.  The date string MUST be enclosed in quotes.  Follow golang specs (https://golang.org/pkg/time/#Time.Format) for date formatting syntax.
--stats-unit=bits|bytes By default, data transfer rates will be printed in bytes per second.
This option allows the data rate to be printed in bits per second.
Data transfer volume will still be reported in bytes.
The rate is reported as a binary unit, not SI unit.  So 1 Mbit/s equals 1,048,576 bit/s and not 1,000,000 bit/s.
The default is bytes.
--suffix=SUFFIX When using sync, copy or move any files which would have been overwritten or deleted will have the suffix added to them.  If there is a file with the same path (after the suffix has been added), then it will be overwritten.
The remote in use must support server-side move or copy and you must use the same remote as the destination of the sync.
This is for use with files to add the suffix in the current directory or with --backup-dir.  See --backup-dir for more info.
rclone copy -i /path/to/local/file remote:current --suffix .bak
will copy /path/to/local to remote:current, but for any files which would have been updated or deleted have .bak added.
If using rclone sync with --suffix and without --backup-dir then it is recommended to put a filter rule in excluding the suffix otherwise the sync will delete the backup files.
rclone sync -i /path/to/local/file remote:current --suffix .bak --exclude "*.bak"
--suffix-keep-extension When using --suffix, setting this causes rclone put the SUFFIX before the extension of the files that it backs up rather than after.
So let's say we had --suffix -2019-01-01, without the flag file.txt would be backed up to file.txt-2019-01-01 and with the flag it would be backed up to file-2019-01-01.txt.  This can be helpful to make sure the suffixed files can still be opened.
--syslog On capable OSes (not Windows or Plan9) send all log output to syslog.
This can be useful for running rclone in a script or rclone mount.
--syslog-facility string If using --syslog this sets the syslog facility (e.g.  KERN, USER).  See man syslog for a list of possible facilities.  The default facility is DAEMON.
--temp-dir=DIR Specify the directory rclone will use for temporary files, to override the default.  Make sure the directory exists and have accessible permissions.
By default the operating system's temp directory will be used: - On Unix systems, $TMPDIR if non-empty, else /tmp.  - On Windows, the first non-empty value from %TMP%, %TEMP%, %USERPROFILE%, or the Windows directory.
When overriding the default with this option, the specified path will be set as value of environment variable TMPDIR on Unix systems and TMP and TEMP on Windows.