Moving Data Between Cloud Providers Safely
Copying files between clouds is easy. Proving nothing was lost, nothing was exposed and the source can finally be deleted is the part that takes planning.
Copying files between providers is easy. Moving a dataset between providers safely, with proof that nothing was lost, nothing was corrupted, nothing was exposed in transit, and the source can finally be deleted with confidence, is a different task. Most of the difficulty is in the last part.
What follows is the sequence that holds up in practice, in the order you should work through it, with the places teams get caught marked out.
Start by deciding what stays behind
The cheapest transfer is the one you do not perform. Before planning anything, go through the dataset and separate it into what the business needs live, what has to be retained for compliance but will never be read, and what nobody can justify keeping at all.
Most estates carry a surprising amount of the third category: old log archives, abandoned project buckets, snapshots of systems retired years ago, duplicate copies made during a previous migration. Moving that data costs money twice, once to transfer and then forever to store.
Retention-only data does not need to land in your new primary storage either. A cheaper archive tier, possibly with a different provider, is usually the right home. Just confirm that retrieval from an archive tier is itself billed and sometimes slow, so anything that might be read quarterly does not belong there.
Three ways data moves, and when each fits
There are only a few mechanisms, and choosing wrongly is the usual cause of a transfer that takes four times longer than planned.
Direct network transfer reads from the source API and writes to the target. It is simple, needs no intermediate storage, and is the right answer for most datasets. Throughput depends on parallelism far more than on raw bandwidth, because object stores are latency-bound per operation rather than throughput-bound. Many small files will be slower than one large file of the same total size, often dramatically so.
Staged transfer pulls to an intermediate location first, usually a compute instance with fast local disk, then pushes onward. Worth the extra step when you need to transform, re-chunk, re-encrypt or verify in the middle, or when the source and target clients do not cooperate well.
Physical transfer means shipping storage media. Providers offer appliances for this. It is slow to arrange and only makes sense at volumes where the network path would take weeks, but at those volumes it is the only realistic option. Factor in the chain of custody and the encryption of the media itself.
A fourth approach, continuous replication, is covered later because it solves a different problem: keeping a changing dataset consistent rather than moving a static one.
The bill comes from the provider you are leaving
Transfer charges are asymmetric. Bringing data into a provider is typically free or close to it. Sending it out is billed by the source, and that charge is what makes migrations expensive.
Several things inflate it beyond the obvious. Per-request charges on object stores add up when a dataset is millions of small objects. Reading from an archive or cold storage tier incurs a retrieval charge on top of the transfer charge, and early-deletion penalties can apply if the data has not been there long enough. Pulling across regions inside the source provider before sending it out charges you twice.
Estimate before you start, using your actual object count and size distribution rather than a total figure. Then run a pilot transfer of a representative slice and check the real line items the next day. Cloud egress fees explained covers how these charges are structured, and why cloud bills surprise people covers the pattern of discovering them late.
Moving data that will not hold still
A static archive is simple. A dataset that is being written to during the transfer is not, because by the time the copy finishes the source has already changed.
The standard approach is a bulk copy followed by incremental catch-up passes. The first pass moves everything and takes the longest. Each subsequent pass moves only what changed since the previous one, and each is shorter than the last. When a pass completes in a window you can tolerate as downtime, you freeze writes, run a final pass, and cut over.
Two details decide whether this works. First, you need a reliable way to identify changes: modification timestamps, version markers or a change feed. Timestamps alone are weak if clocks or client behaviour are inconsistent. Second, deletions must propagate. A sync that only copies new and modified objects leaves deleted objects alive on the target, which quietly breaks anything that lists a prefix and acts on the result.
Proving the copy is actually the copy
Do not accept “the tool finished without errors” as verification. Tools report success on partial transfers more often than you would like, especially where permissions silently blocked a subtree.
Verify on three levels. Count objects on both sides and compare exactly; any gap needs explaining before you continue. Compare total bytes, which catches truncation that a count will not. Then compare content hashes, either for every object if the dataset size allows or for a random sample plus every object above a size threshold if it does not.
Checksum comparison across providers needs care, because providers compute object hashes differently, particularly for multipart uploads where the stored value may be a hash of hashes rather than of the content. If the native values are not comparable, compute your own hash during the transfer and store it as metadata on both sides.
Keep the verification output. When someone asks in nine months whether a particular archive made it across, a saved manifest answers in a minute.
Encryption and who holds the keys
Transport should be encrypted end to end, which is usually the default but is worth confirming rather than assuming, especially if a transfer passes through an intermediate host you built quickly.
Encryption at rest is the part that needs a decision. If the source data is encrypted with provider-managed keys, those keys do not travel. The data is decrypted on read and re-encrypted on write at the target with a different key under a different provider’s control. That is usually fine, but it means there is a window where the plaintext passes through your transfer process, and that process should run somewhere you trust and log appropriately.
If you encrypt with your own keys before the data reaches either provider, the transfer becomes a straightforward copy of opaque blobs and the key question stays with you. That is the stronger position for sensitive material, and it needs a working key management practice behind it, which is the subject of cloud secrets management.
Credentials used for the transfer deserve the same discipline. Create a dedicated identity on each side, scoped to exactly the paths involved, with an expiry. Delete it when the transfer completes. Long-lived broad credentials created for a migration have a habit of outliving the migration.
Databases are not files
A database is not moved by copying its storage. Treat it as a separate project with its own plan.
For a relational database you have three broad options. A dump and restore during a maintenance window is simplest and is bounded by how long the business will accept being offline. Logical replication from source to target lets you keep the target current and cut over in minutes, at the cost of setup complexity and a compatibility check between versions. A managed migration service, where the target provider offers one, automates much of this but still needs the same verification.
Whichever route, verify with row counts per table, aggregate checks on numeric columns, and a sample of full-row comparisons. Then confirm the things a data copy does not carry: sequence positions, stored procedures, grants, extensions, scheduled jobs and collation settings. A migration that lands all the rows but resets a sequence will corrupt new writes within hours.
Throughput is a tuning exercise
First transfers are almost always slower than expected, and the bottleneck is rarely the link. Common causes are too little concurrency, a single-threaded client, rate limiting on the source API, an undersized intermediate instance, or a request pattern that lands on one storage partition.
Raise parallelism gradually and watch for throttling responses rather than guessing. Run the transfer from a machine in the same region as one endpoint, ideally the source. Group tiny files into archives before moving them if the object count is in the millions. Run a timed pilot on a representative slice and extrapolate from measured throughput, not from the theoretical link speed.
Cutover, and when to press delete
At cutover, stop writes at the source, run the final incremental pass, verify, then repoint your applications. Watch for anything still writing to the old location: a batch job, a partner integration, a backup script. Making the source read-only rather than deleting it surfaces those immediately and harmlessly.
Keep the source intact for an agreed period after cutover. The right moment to delete is when the target has been serving production for long enough to cover your slowest business cycle, including month-end processing, and when you have an independent backup of the target. Storage for an extra few weeks is cheap. Discovering a gap after the source is gone is not.
Where you are moving to
Transfer planning is easier when the target is already provisioned and you can run a pilot immediately rather than waiting on procurement. If you are weighing European or value-focused destinations for bulk storage, our Hetzner and OVHcloud comparison covers how the two approach storage and bandwidth. On TrustCloudHub you can review verified listings for a Buy OVH Account, a Buy Contabo Account or a Buy Scaleway Account. We are an independent marketplace and not a provider partner, so check region availability, storage limits and any credit balance inside the provider’s own console after handover. Credits are provider-controlled, expire, and often exclude storage or transfer charges, so do not build a transfer budget around them.