Guide · Moving data at scale

How to transfer petabytes of data.

How long a petabyte really takes, why big transfers run far slower than the link you pay for, and what it takes to move data at line rate — with a transfer-time table, the options compared, and a checklist.

Updated November 18, 2026 · by the Zettar team
The short answer. On a 100 Gbps link running at line rate (about 90% utilization), a petabyte moves in roughly a day; on 10 Gbps it takes about ten days. Most transfers fall far short of that — not because of the network, but because storage I/O, hosts, and single-stream software can’t keep the link full. Reaching line rate means engineering the whole data path: parallel, scale-out movement, an NVMe burst buffer between storage and the network, and end-to-end integrity checks.

How long does it take to transfer a petabyte?

Transfer time is data size divided by the throughput you actually achieve — not the link’s nameplate speed. The table assumes a well-engineered path that sustains about 90% of the link (line rate).

Data10 Gbps25 Gbps100 Gbps400 Gbps
10 TB2.5 h59 min15 min4 min
100 TB25 h9.9 h2.5 h37 min
1 PB10 days4.1 days25 h6.2 h
10 PB103 days41 days10 days2.6 days

Formula: hours = data (TB) ÷ (link Gbps × 0.9 × 0.45 TB per hour per Gbps). If your tools realize only part of the link, scale accordingly — at 20% utilization, a petabyte on a 100 Gbps link takes about 4.6 days instead of one. Try your own numbers in the transfer-time calculator.

Why do big transfers run slower than your link?

Once a fast link is in place, the network is rarely the bottleneck. Throughput is set by the slowest part of the end-to-end path:

  • Storage I/O, especially writes. Production file systems and object stores are built for capacity and concurrency, not for feeding one fast pipe. When the receiver can’t commit data fast enough, the network waits.
  • Single-stream software. One TCP stream must keep the whole bandwidth-delay product in flight — about 1.25 GB on a 100 Gbps path with a 100 ms round trip. Single-stream tools can’t, so long, fast paths sit mostly idle.
  • Host architecture. CPU, memory, PCIe, and NIC placement all cap what one server can push.
  • Security and integrity overhead. Encryption and checksums are non-negotiable at this scale, so they have to be engineered into the path rather than bolted on.

That is why buying a bigger link alone rarely makes a transfer faster. The network isn’t the bottleneck — the whole path is.

What are your options?

ApproachGood forWhere it falls short at petabyte scale
General-purpose tools (rsync, scp)Everyday sync between two hostsSingle stream, so fast links stay mostly idle; scaling means hand-sharded scripts
Grid and managed-transfer tools (Globus, MFT)Orchestration, sharing, governanceThroughput still depends on the endpoints and storage you tune yourself
Shipping drives or transfer devicesOne-time moves with no usable networkLoad, transit, and unload time; data leaves your custody; no help for recurring or continuous flows
Cloud providers’ standard transfer paths and CLIsConvenience inside one cloudStandard paths carry a performance penalty — in one measured case zx was 5.9× faster than aws-cli
A co-designed data-movement appliancePetabyte-scale, recurring, multi-site movementA capital purchase — worth it when data movement is on the critical path

For a deeper comparison, see rsync vs Globus vs a data-movement appliance, or the head-to-heads with rsync, Globus, and Aspera.

A checklist for moving petabytes

  • Measure the whole path, not just the link. Test storage read and write throughput at both ends, not only the network.
  • Stage through fast storage. An NVMe burst buffer decouples slow, bursty storage I/O from the network.
  • Move in parallel and scale out. Many streams across many nodes, so no single stream, file, or server caps throughput.
  • Verify every byte. End-to-end checksums on every file or object, plus encryption in transit.
  • Plan for distance. Use a mover that holds throughput on long, high-latency paths.
  • Keep native formats. Avoid proprietary wrappers, so data lands ready to use and nothing is locked in.
  • Size the cutover. For migrations, every extra day means running two environments — estimate the overlap cost.

What line rate looks like in practice

With SLAC National Accelerator Laboratory and ESnet (U.S. DOE), Zettar moved 1 PB in 29 hours over a 5,000-mile path, encrypted and checksummed, at 96% link utilization — while capped at 80 Gbps to share the network. On a full 100 Gbps link, that is a petabyte a day. In a separate test, zx moved a 1.2 TiB cryo-EM dataset from KEK in Japan to AWS N. Virginia in about 40 minutes, versus 235 minutes for aws-cli (Fang et al., arXiv:2512.15028).

The Zettar zx Appliance packages that engineering — storage, host, network, and software co-designed, with an NVMe burst buffer — as one turnkey, pretuned system, so you get line rate the day it is racked.

Estimate your transfer time → Read the research →

FAQ

Common questions

How long does it take to transfer a petabyte?

At line rate on a 100 Gbps link (about 90% utilization), roughly a day; on 10 Gbps, about ten days. With SLAC and ESnet, Zettar moved 1 PB in 29 hours over a 5,000-mile path while capped at 80 Gbps.

What is the fastest way to transfer a very large dataset?

A network path engineered for line rate: parallel, scale-out movement across many streams and nodes, an NVMe burst buffer between storage and the network, and end-to-end checksums. That sustains about 90% of the link — roughly a petabyte a day on 100 Gbps. Shipping drives mainly wins when there is no usable network, or the link is very slow for a one-time move.

Why is my transfer so much slower than my link speed?

Usually the network is not the bottleneck: storage I/O (especially writes), host architecture, single-stream software, and security overhead cap throughput. Reaching line rate means engineering the whole path — parallel, scale-out movement and an NVMe burst buffer between storage and the network.

Does distance or latency slow down a large transfer?

With single-stream TCP tools, yes — one stream cannot keep a long, fast path full. A parallel, scale-out mover is largely latency-insensitive: Zettar was validated on 10–100 ms paths and on 5,000- and 12,375-mile transfers.

What link utilization should we expect?

A well-engineered path should sustain about 90% or more of available bandwidth. Zettar's SLAC and ESnet record averaged 96%.

How do we make sure nothing is corrupted or exposed?

Use end-to-end checksums on every file or object and encrypt data in transit. Zettar applies unconditional end-to-end checksums and TLS on every transfer, so every byte arrives provably intact.

See it for yourself

Move your next petabyte in a day.

See the appliance move data at line rate — or talk through your transfer with an engineer.