How to Transfer Multiple Files with croc: A Complete Guide

Use croc send followed by multiple file paths or a wildcard pattern to transfer several files in a single secure session; croc automatically multiplexes the transfer across parallel TCP ports unless you disable it with --no-multi.

croc is a command-line file transfer tool that moves data securely between computers without prior setup or server configuration. Transferring multiple files with croc requires only listing the files after the send command, as the tool automatically manages parallel streams for optimal throughput. This guide explains the exact command syntax and internal mechanics according to the schollz/croc source code, including how multiplexing works and when to disable it.

Basic Syntax for Sending Multiple Files

When you invoke the send command, croc treats every argument after it as a file or folder to be transferred. You can specify individual files, use shell wildcards, or pass entire directories.

Sending Specific Files

List each filename separated by a space. croc will package them into a single transmission session sharing one security code:

croc send file1.txt file2.txt file3.txt

Using Wildcards

Your shell expands glob patterns before croc processes them, allowing batch selections:

croc send *.jpg

Sending Folders

When you pass a directory, croc recursively collects its contents. The folder structure is preserved on the receiving end:

croc send my_picture_folder

How croc Handles Multiple Files Internally

The multi-file capability relies on multiplexing—opening several parallel data streams across different TCP ports. This architecture is implemented across three core files in the repository.

Argument Parsing in src/cli/cli.go

The send command is registered in src/cli/cli.go, which parses the argument list containing your filenames. Whether you provide explicit paths or wildcards, the CLI collects them into a slice that is passed to the core client. This file also registers the --transfers and --no-multi flags that control downstream behavior.

Multiplexing Logic in src/croc/croc.go

The core client implementation in src/croc/croc.go governs whether to use multiple ports. The NoMultiplexing boolean option determines the flow:

• When false (the default), croc retains the full list of relay ports returned by the control connection
• When true (triggered by --no-multi), only the first port is used for all data

The file transfer loop c.transferWithReconnect iterates over the supplied paths, encrypts each chunk with the shared session key, and distributes chunks across the available ports. Because all files share the same session key and code phrase, the receiver only needs a single command to reconstruct the entire batch.

TCP Connection Setup in src/tcp/tcp.go

The low-level networking in src/tcp/tcp.go opens a TCP connection for each port listed in c.Options.RelayPorts. The Options struct (defined in src/tcp/options.go) stores the Transfers and NoMultiplexing values that drive this logic. By default, croc opens four parallel connections, though this is configurable.

Optimizing Transfer Performance

You can tune how croc handles multiple files by adjusting the parallelism or disabling it entirely.

Adjusting Parallel Transfers (--transfers)

The --transfers flag controls how many TCP ports croc uses simultaneously. The default is 4, but you can increase this for high-bandwidth networks:

croc send --transfers 8 bigvideo.mkv otherfile.pdf

Increasing the transfer count allows more files to move concurrently, though it consumes more system resources and requires more open ports on both sender and receiver.

Disabling Multiplexing (--no-multi)

If you operate behind a strict firewall that blocks additional ports, force single-port mode:

croc send --no-multi fileA.bin fileB.bin

Setting --no-multi sets c.Options.NoMultiplexing to true in src/croc/croc.go, restricting the entire batch to one TCP connection. This trades speed for firewall compatibility.

Receiving Multiple Files

The receiver does not need to know how many files are coming. A single command downloads the entire batch:

croc <code>

croc displays progress for each file individually and writes them to the current directory. If you specify --out <dir> when receiving, all files are placed in that target folder while maintaining their relative directory structure.

Summary

• Multiple files are sent by listing them after croc send, or using wildcards like *.jpg
• Multiplexing automatically splits transfers across parallel ports (default 4) for faster throughput, controlled by the NoMultiplexing option in src/croc/croc.go
• Optimization is available via --transfers (increase parallelism) or --no-multi (disable parallelism for firewalls)
• Single session encryption means all files share one code phrase and session key, requiring only one command on the receiving side
• Key files implementing this behavior include src/cli/cli.go (parsing), src/croc/croc.go (orchestration), and src/tcp/tcp.go (connections)

Frequently Asked Questions

Can I transfer multiple files with a single croc command?

Yes. Simply list all files after croc send, separated by spaces, or use shell wildcards. The receiver only needs to run croc <code> once to download all files in the batch, as they share the same encryption key and session.

How many files can I send at once with croc?

There is no hardcoded limit in the source code. You can send hundreds of files via wildcard patterns or explicit arguments. However, extremely large batches may approach operating system limits on open file descriptors or command-line argument length.

Why is croc opening multiple ports when I send files?

This is multiplexing, a feature enabled by default in src/croc/croc.go. By opening several parallel TCP connections (controlled by the --transfers flag), croc increases total throughput by sending different file chunks simultaneously over separate ports. All connections use the same session key for end-to-end encryption.

What if my firewall blocks the extra ports?

Use the --no-multi flag to force single-port mode. This sets c.Options.NoMultiplexing to true, causing croc to use only the first relay port for the entire transfer. While this bypasses restrictive firewalls, it reduces transfer speed because files must stream sequentially rather than in parallel.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}