A practical, safety-first guide for copying projects inside Backblaze B2, uploading local files, verifying the result, and recovering from interrupted work.

Guide baseline: rclone 1.75.0 · Terminal app on macOS · Last reviewed August 29, 2026

1. Purpose, scope, and ground rules

This guide is for employees who need to:

  • copy a project from one B2 prefix to another;
  • upload a local folder or an individual recovery file to B2;
  • verify that the destination contains everything from the source; or
  • safely restart a job that stopped.

The examples use an rclone remote named b2:. Your remote may have a different name. Run rclone listremotes to confirm it before copying an example.

Safety rule: use copy unless a supervisor has specifically approved sync. A copy does not delete destination-only files. A sync can.

Never paste a Backblaze application key into a command, chat, screenshot, or log. Credentials belong in the rclone configuration created by rclone config.

Install or update on macOS

Open the Terminal app on your Mac. If rclone is not installed and Homebrew is available:

brew install rclone

If Homebrew installed rclone previously, update it with:

brew update
brew upgrade rclone

Confirm the installed version:

rclone version

This guide’s tested baseline is rclone 1.75.0. If the Terminal app reports an older version, update it before a production transfer.

Configure a B2 remote only if one does not already exist:

rclone config

Use a restricted Backblaze application key appropriate for the required buckets. Do not display or share the rclone configuration file.

2. The mental model

Buckets, objects, and prefixes

B2 stores objects rather than computer-style folders. Each object has a name that can contain slashes, such as 2026/26016_CZ_final/shot_01.mov. The portion before the filename is a prefix. In everyday use, you can read “prefix” as “folder.”

The shape of a B2 address

remote:bucket-name/prefix/path
  • remote: is the saved rclone connection. The colon is required.
  • bucket-name is the top-level B2 bucket.
  • everything after the first slash is the prefix inside that bucket.

For example, b2:Utopic-Cloud-Archive/2026/26016_CZ_final means the 2026/26016_CZ_final prefix in the Utopic-Cloud-Archive bucket.

Spelling, capitalization, punctuation, and spaces matter. Put every path in quotation marks, even when it contains no spaces. That habit prevents avoidable command errors.

What “server-side copy” means

When the source and destination use the same B2 remote, rclone can ask B2 to copy the objects within B2. The data does not need to pass through your computer. Your computer still coordinates the job, so keep rclone running until it finishes.

At --log-level INFO, successful server-side work is identified in the log. Upload-only settings such as --b2-chunk-size do not tune a normal same-remote B2-to-B2 copy.

3. Terminal syntax on macOS

Forward slashes build paths

Use forward slashes inside B2 paths: 2026/26016_CZ_final.

Backslashes continue long commands

In the Terminal app on your Mac, a backslash at the end of a line means the command continues on the next line:

rclone copy \
  "SOURCE" \
  "DESTINATION" \
  --dry-run

The backslash must be the final character on its line—no trailing spaces.

Local paths

A Mac local path looks like /Users/yourname/Desktop/shot_01.mov. Dragging a file or folder from Finder into the Terminal app inserts its local path; still place the result in quotation marks.

4. Commands: choose the right action

**copy**: copy a directory or set of files

rclone copy SOURCE DESTINATION copies files from the source into the destination. It skips identical files already present and does not delete destination-only files. If the same path already exists but differs, rclone can update it.

The contents of the source directory are copied into the destination; rclone does not automatically add the source directory’s final name. Check both paths carefully during the dry run.

**copyto**: copy one exact file to one exact path

Use rclone copyto when both sides name a file. This is the clearest command for downloading one failed object and uploading its replacement to the exact intended B2 path.

**check**: compare source and destination

Use rclone check after a copy. With --one-way, it confirms that everything in the source exists at the destination while allowing unrelated destination files.

**sync**: make the destination match the source

Sync can delete destination-only files. It is intentionally excluded from the everyday workflows in this guide. Use it only with explicit approval and a reviewed dry run.

5. Read-only preflight

Run these checks before building a transfer command. They do not change B2.

rclone version
rclone listremotes
rclone lsd "b2:"
rclone lsf "b2:SOURCE-BUCKET/SOURCE-PREFIX" --max-depth 1
mkdir -p "$HOME/b2-logs"

Confirm all of the following:

  • rclone reports version 1.75.0.
  • the expected remote appears in rclone listremotes.
  • both source and destination bucket names are correct.
  • the source listing looks like the project you intend to copy.
  • the log folder exists.

If the remote name is not b2:, replace b2: in every example. Do not create a second remote merely to match this guide.

6. B2-to-B2 copy profiles

These are starting profiles. More parallel work is not automatically faster. Begin with the standard profile and use the troubleshooting profile only when the log shows repeated throttling or instability.

Standard profile — start here

Uses rclone’s normal transfer and checker defaults, adds an efficient listing, keeps an INFO log, and shows progress.

caffeinate -i rclone copy \
  "b2:SOURCE-BUCKET/SOURCE-PREFIX" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX" \
  --fast-list \
  --log-level INFO \
  --log-file "$HOME/b2-logs/rclone-$(date +%Y%m%d-%H%M).log" \
  -P \
  --dry-run

Large-project profile — measured increase

For a project containing many objects, a reasonable tested starting point is 8 transfers and 16 checkers. Watch the log and reduce these values if B2 repeatedly throttles the job.

caffeinate -i rclone copy \
  "b2:SOURCE-BUCKET/SOURCE-PREFIX" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX" \
  --fast-list \
  --transfers 8 \
  --checkers 16 \
  --log-level INFO \
  --log-file "$HOME/b2-logs/rclone-$(date +%Y%m%d-%H%M).log" \
  -P \
  --dry-run

Throttled profile — when the log repeatedly shows 429 responses

This profile lowers concurrency and caps transactions per second. It may be slower, but can make progress steadier when B2 is asking rclone to back off.

caffeinate -i rclone copy \
  "b2:SOURCE-BUCKET/SOURCE-PREFIX" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX" \
  --fast-list \
  --transfers 2 \
  --checkers 4 \
  --tpslimit 5 \
  --log-level INFO \
  --log-file "$HOME/b2-logs/rclone-$(date +%Y%m%d-%H%M).log" \
  -P \
  --dry-run

--tpslimit is a troubleshooting control, not a required flag for every copy. Rclone already retries many temporary failures.

7. The safe B2-to-B2 workflow

Step 1 — create the log folder

mkdir -p "$HOME/b2-logs"

Step 2 — replace both example paths

Write the source first and the destination second. Read them aloud as “copy from source to destination.” Do not run the command until both are exact.

Step 3 — dry run

Add --dry-run to the selected profile. A dry run shows what rclone would do without transferring data. Read the proposed paths and file activity.

Step 4 — real run

Remove only --dry-run. Run the otherwise identical command. Keep the terminal open and the computer awake until rclone returns to the normal prompt.

Step 5 — verify

Run the verification commands in Section 10. A completed transfer is not considered finished until it has been checked.

8. Uploading local files to B2

An upload is different from a server-side B2-to-B2 copy: bytes travel from the local computer to B2. Upload speed, local network stability, multipart settings, and memory can therefore matter.

Upload a local folder

Use copy. As always, dry-run first.

caffeinate -i rclone copy \
  "/Users/yourname/Desktop/PROJECT-FOLDER" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX" \
  --fast-list \
  --log-level INFO \
  --log-file "$HOME/b2-logs/upload-$(date +%Y%m%d-%H%M).log" \
  -P \
  --dry-run

Upload one recovery file to one exact B2 path

Use copyto so the destination includes the exact filename.

caffeinate -i rclone copyto \
  "/Users/yourname/Desktop/shot_01.mov" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX/shot_01.mov" \
  --log-level INFO \
  --log-file "$HOME/b2-logs/upload-one-$(date +%Y%m%d-%H%M).log" \
  -P \
  --dry-run

Download and re-upload one failed object

Use this recovery sequence only after confirming the object that failed and its exact destination path.

# 1. Download the exact source object.
rclone copyto \
  "b2:SOURCE-BUCKET/SOURCE-PREFIX/shot_01.mov" \
  "/Users/yourname/Desktop/shot_01.mov" \
  -P

# 2. Dry-run the exact replacement upload.
rclone copyto \
  "/Users/yourname/Desktop/shot_01.mov" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX/shot_01.mov" \
  --dry-run

# 3. Remove --dry-run, upload, then verify that file in its destination directory.
rclone check \
  "/Users/yourname/Desktop/shot_01.mov" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX" \
  --one-way

Multipart upload guardrails

Start with rclone’s defaults. Change multipart settings only when a log or a specific performance test gives you a reason.

  • --b2-upload-cutoff controls when an upload becomes multipart.
  • --b2-chunk-size controls the part size used for large uploads.
  • --b2-upload-concurrency controls how many parts per file can upload simultaneously.
  • --b2-copy-cutoff concerns large server-side copies; it is not the local-upload cutoff.

Large chunk sizes can use substantial memory. A useful upper-bound estimate for multipart upload buffers is:

transfers × upload concurrency × chunk size

For example, 8 transfers × 4 upload streams × 500 MiB is about 16 GiB of potential buffer memory. Do not copy large tuning values from another job without recalculating this estimate for the computer being used.

9. Flags, grouped by purpose

Safety and visibility

  • --dry-run previews the operation without changing data.
  • -P displays live progress.
  • --log-level INFO records useful transfer detail without DEBUG-level noise.
  • --log-file PATH saves the run for review.

Listing and concurrency

  • --fast-list uses more memory to reduce listing transactions on remotes that support it; it is useful for large listings.
  • --transfers N sets the number of file transfers running in parallel.
  • --checkers N sets the number of parallel checks.
  • --tpslimit N caps transactions per second; use it to respond to repeated throttling.
  • --bwlimit RATE limits data bandwidth. This matters for local uploads and downloads, but not the B2 data path of a server-side copy.

Retries

Rclone normally retries temporary failures. --retries 1 reduces the normal high-level retry count, so do not add it merely to make a command look more deliberate. Let the standard retry behavior work unless troubleshooting calls for a specific change.

--ignore-errors does not make copy safer or more resilient. Its documented role concerns deletion during sync-like operations, so it is not part of these copy profiles.

10. Verify the result

Primary verification: **rclone check**

rclone check \
  "b2:SOURCE-BUCKET/SOURCE-PREFIX" \
  "b2:DESTINATION-BUCKET/DESTINATION-PREFIX" \
  --one-way \
  --fast-list

--one-way checks that source files exist and match at the destination while ignoring extra destination files. --fast-list can reduce listing transactions for a large comparison.

The check result—not merely the command’s return to the prompt—is the important evidence. Read the summary and investigate every reported ERROR.

Supplementary comparison: **rclone size**

rclone size "b2:SOURCE-BUCKET/SOURCE-PREFIX"
rclone size "b2:DESTINATION-BUCKET/DESTINATION-PREFIX"

Matching counts and byte totals are reassuring, but size alone is weaker than rclone check. Treat it as a supplementary confirmation.

Large files without a comparable whole-file hash

Some large multipart objects may not have a whole-file hash that rclone can compare directly. Read the check output carefully. For a small, identified subset, a size comparison or a deliberate check using --download can provide additional certainty, but --download transfers the file data and can be slow and costly.

11. Troubleshooting and recovery

The job stopped or the terminal closed

Run the same copy command again. Rclone rechecks the paths, skips files that already match, and transfers work that remains. This is restart-friendly behavior; it is not a guarantee that a partially uploaded individual file resumes from the exact byte where it stopped.

Repeated 429 or “too many requests” messages

Occasional retry messages can resolve on their own. If the log repeatedly shows throttling and the job makes poor progress, use the throttled profile. Do not increase transfers or checkers while diagnosing rate limiting.

A small number of files will not copy

Record each exact source path and the corresponding destination path. Retry them with copyto. If a server-side copy still fails, use the single-file recovery sequence in Section 8, then verify those files against their final B2 paths.

The command returned an error

Do not erase or overwrite the log. Search it for ERROR, note the first meaningful error and the final summary, and share the log with the person helping you. Remove credentials if a command was accidentally written into the log before sharing it.

Keep the Mac awake

The B2-to-B2 and upload examples begin with caffeinate -i. It keeps the Mac from idle sleeping while rclone is running. Closing the laptop, quitting the Terminal app, restarting, or losing power can still interrupt the job.

12. Quick reference

Goal Command
Show the rclone version rclone version
List configured remotes rclone listremotes
List B2 buckets rclone lsd "b2:"
List one prefix rclone lsf "b2:BUCKET/PREFIX"
Copy a folder or set rclone copy SOURCE DESTINATION
Copy one exact file rclone copyto SOURCE_FILE DESTINATION_FILE
Verify a copy rclone check SOURCE DESTINATION --one-way
Count files and bytes rclone size PATH
Preview safely add --dry-run
Show progress add -P

Before you press Return

13. Maintenance notes and authoritative links

This guide is generated from one shared source. The macOS and Windows editions intentionally differ only where the operating system or shell requires different commands. Edit the shared source for common guidance; edit platform fragments only for genuine OS differences.

Review the guide whenever rclone’s baseline version changes or a production transfer reveals a new recovery case.