How to Migrate Data from MySQL to Snowflake Destination?

Migrating from MySQL to Snowflake is rarely just a copy-and-paste exercise. Schema differences, data volume, and reliability all come into play. The sections below walk through each approach step by step, explain when to use which method, and highlight the trade-offs to help you choose the most practical path forward.

Right below, you’ll find a short walkthrough video showing what an end-to-end MySQL → Snowflake migration looks like in practice.

Why move MySQL data to Snowflake?

• Scalability and Performance
  MySQL is designed for transactional workloads and can struggle as data volumes and query concurrency grow. Snowflake’s cloud-native architecture scales storage and compute independently, making it better suited for large datasets and complex analytical queries.
• Advanced Analytics Capabilities
  Snowflake supports modern analytics workflows, including large-scale aggregations, BI workloads, and SQL-based machine learning. This makes it easier to run advanced analysis directly on historical and near-real-time data.
• Cost Efficiency at Scale
  Snowflake’s pay-as-you-go pricing model lets you pay only for the compute and storage you use. Separating compute from storage helps control costs as workloads grow, compared to maintaining and scaling MySQL infrastructure.
• Easier Data Integration and Sharing
  Snowflake integrates easily with BI tools, ETL platforms, and other cloud services. Its secure data-sharing features also make it simpler to collaborate across teams or share data with external partners.
• Reduced Operational Overhead
  Snowflake is fully managed, handling tasks like infrastructure provisioning, scaling, backups, and patching. This reduces the operational burden compared to managing MySQL servers and allows teams to focus on analytics instead of maintenance.

You can also move data from GCP MySQL to Snowflake within minutes for seamless data integration.

Step-by-Step Approach To Perform MySQL-Snowflake Migration

Migrating data from MySQL to Snowflake can be approached in different ways depending on your need for automation, real-time updates, and operational effort. Broadly, teams use three proven methods to move data reliably from MySQL into Snowflake, ranging from fully automated pipelines to manual, one-time transfers.

The three commonly used methods are:

• Method 1: Automated ETL using Hevo – A fully managed, no-code approach for continuous replication with minimal maintenance.
• Method 2: Snowflake Connector for MySQL – A native CDC-based solution that uses Snowflake-managed infrastructure for ongoing synchronization.
• Method 3: Manual export and load – A high-effort method best suited for one-time migrations or small datasets.
  

Each method comes with different trade-offs in terms of setup complexity, scalability, and long-term maintenance, which we’ll walk through step by step below.

Method 1: Using Hevo (Automated MySQL to Snowflake Migration)

Hevo is a fully managed, no-code data pipeline platform that automates both historical data migration and ongoing incremental replication from MySQL to Snowflake. It removes the operational overhead of managing connectors, CDC configurations, and schema changes, making it the most practical choice for teams that want reliable, production-grade pipelines without custom engineering.

Hevo supports log-based CDC, automatic schema handling, built-in monitoring, and fault-tolerant retries, so your MySQL data stays continuously in sync with Snowflake.

When to Use Hevo

• You need continuous replication (not just a one-time load)
• You want CDC without managing binlogs, agents, or Docker
• Your team prefers no-code or low-code setup
• You want observability, alerts, and recovery built in

Step-by-Step: Load Data from MySQL to Snowflake Using Hevo

Hevo uses BinLog-based Change Data Capture (CDC) to replicate MySQL data into Snowflake with minimal setup and no custom code.

Step 1: Create a New Pipeline

1. Log in to Hevo
2. Go to PIPELINES → click + Create Pipeline
3. Select MySQL as the Source
4. Select Snowflake as the Destination
   

Step 2: Choose Pipeline Mode

1. Select BinLog as the Pipeline Mode
   • Required for CDC-based MySQL pipelines
2. Choose Standard Pipeline (Edge is optional and eligibility-based)
3. Click Continue
   

Step 3: Configure MySQL as the Source

1. Enter your MySQL connection details:

• Source Name (unique identifier)
• Database Host (IP or DNS, without http/https)
• Port (default: 3306)
• Database User & Password
• Database Names (comma-separated list)

2. Optional (recommended for security):

• Enable SSH if the database is private
• Enable SSL for encrypted connections

3. Click Test & Continue to validate the connection.

Step 4: Configure Snowflake as the Destination

1. Provide the following Snowflake details:

• Destination Name
• Account Identifier (account.region.cloud)
• Username / Authentication method
• Warehouse
• Database
• Schema
• Role

Optional:

• Enable Loaded Timestamp
• Enable Table/Column Name Sanitization
  

2. Click Test Connection, then Save & Continue.

Step 5: Select Tables and Enable CDC

1. Choose the MySQL tables to replicate
2. Hevo performs:
   • Initial full load
   • Continuous BinLog-based CDC (INSERT, UPDATE, DELETE)
3. Enable the pipeline

Once live, Hevo automatically handles:

• Incremental replication
• Schema changes
• Retries and fault tolerance
• Pipeline health and observability

No agents, scripts, or manual maintenance required.

Method 2: Using the Snowflake Connector for MySQL (Native CDC)

The Snowflake Connector for MySQL is Snowflake’s official, native solution for continuously replicating MySQL data into Snowflake using Change Data Capture (CDC).

This method works best if you want tight Snowflake-native integration and are comfortable managing some infrastructure.

Prerequisites

Before you begin, ensure the following are in place:

• MySQL 8.0+ with binary logging enabled

(binlog_format = ROW, binlog_row_image = FULL)

• A MySQL user with REPLICATION SLAVE, REPLICATION CLIENT, and SELECT privileges
• A Snowflake account with appropriate admin permissions
• Docker is installed on a machine that can access MySQL
• Network connectivity between MySQL and Snowflake

Step-by-Step: Set Up Snowflake Connector for MySQL

Step 1: Install the Connector from Snowflake Marketplace

1. Log in to Snowsight.
2. Go to Data Products → Marketplace.
3. Search for Snowflake Connector for MySQL.
4. Click Get, select a warehouse, and install the application.

The connector will appear under Apps in Snowsight.

Step 2: Create an Event Table for Monitoring

Snowflake uses an event table to track connector status and CDC progress.

CREATE EVENT TABLE IF NOT EXISTS mysql_connector_events;

ALTER ACCOUNT SET EVENT_TABLE = mysql_connector_events;

This enables observability and troubleshooting.

Step 3: Deploy the Connector Agent (Docker)

The connector relies on an agent running inside your network.

1. Pull the Docker image:

docker pull snowflakedb/mysql-cdc-agent:latest

2. Create an agent configuration file with:

• MySQL host, port, user, password
• Snowflake account, warehouse, database, schema
• Key-pair authentication for Snowflake

3. Run the agent:

docker run -d \

  -v $(pwd)/agent-config.json:/config/agent-config.json \

  snowflakedb/mysql-cdc-agent:latest

The agent continuously reads MySQL binlogs and streams changes.

Step 4: Configure Replication in Snowsight

1. Open the installed connector app.
2. Create a source connection to MySQL.
3. Select tables to replicate.
4. Choose replication mode:
   • Initial load only
   • CDC only
   • Initial load + CDC (recommended)

Step 5: Start Replication

Once enabled, the connector:

• Performs an initial snapshot of selected tables
• Streams ongoing INSERT, UPDATE, DELETE events
• Loads data into Snowflake using Snowpipe Streaming
  

Step 6: Monitor and Validate

1. Verify data replication:

SELECT * FROM target_database.target_schema.your_table LIMIT 10;

2. Monitor connector health:

SELECT * FROM mysql_connector_events ORDER BY timestamp DESC;

Limitations to Keep in Mind

• Less flexible than managed ETL tools for complex pipelines
• Requires Docker and agent management
• Limited transformation capabilities (raw replication)
• Schema changes require careful handling

Method 3: Manual Export and Load from MySQL to Snowflake

The manual export-and-load approach involves dumping data from MySQL into flat files (such as CSV), staging them in cloud storage, and then loading them into Snowflake using:

COPY INTO

This method is best suited for one-time migrations or small datasets, not continuous syncing.

Step-by-Step: Manual MySQL to Snowflake Migration

Step 1: Export Data from MySQL

Use mysqldump or a direct SQL export to generate CSV files.

Option A: Export using SELECT INTO OUTFILE

SELECT * 

INTO OUTFILE '/tmp/customers.csv'

FIELDS TERMINATED BY ','

ENCLOSED BY '"'

LINES TERMINATED BY '\n'

FROM customers;

Option B: Export using mysqldump (data only)

mysqldump \

  --user=mysql_user \

  --password \

  --tab=/tmp \

  --fields-terminated-by=',' \

  --fields-enclosed-by='"' \

  --lines-terminated-by='\n' \

  your_database customers

Tip: Compress large files (gzip) to reduce upload time.

Step 2: Upload Files to Cloud Storage

Snowflake loads data from a staging location. Upload your files to:

• Amazon S3
• Google Cloud Storage
• Azure Blob Storage

Example (AWS S3):

aws s3 cp /tmp/customers.csv.gz s3://my-bucket/mysql-export/

Step 3: Create a Stage in Snowflake

1. Define a Snowflake stage pointing to your cloud storage.

CREATE OR REPLACE STAGE mysql_stage

  URL='s3://my-bucket/mysql-export/'

  CREDENTIALS=(AWS_KEY_ID='xxx' AWS_SECRET_KEY='yyy')

  FILE_FORMAT = (TYPE = CSV SKIP_HEADER = 1);

Step 4: Create Tables in Snowflake

1. Manually create tables with schemas compatible with Snowflake data types.

CREATE OR REPLACE TABLE customers (

  id INTEGER,

  name STRING,

  email STRING,

  created_at TIMESTAMP

);

Note: MySQL and Snowflake data types differ—JSON, DATETIME, and BOOLEAN fields often need special handling.

Step 5: Load Data into Snowflake

1. Use COPY INTO to ingest the files.

COPY INTO customers

FROM @mysql_stage/customers.csv.gz

FILE_FORMAT = (TYPE = CSV SKIP_HEADER = 1);

2. Validate row counts and sample data after load.

Run checks to ensure data accuracy:

• Row counts (MySQL vs Snowflake)
• NULL handling
• Timestamp and timezone correctness
• Character encoding issues

Limitations of the Manual Method

• Not suitable for ongoing analytics pipelines
• No automation or incremental updates 
• No built-in CDC or change tracking
• High operational effort as schemas evolve
• Error-prone for large or frequently changing datasets

You can also Learn more about:

• MySQL to Databricks
• GCP MySQL to Databricks
• Azure MySQL to Snowflake
• Setting Up Databricks ETL

Conclusion

Migrating data from MySQL to Snowflake is a strategic step for teams that want to scale analytics, improve query performance, and move away from operational database constraints. As covered in this guide, you can approach the migration manually, use Snowflake’s native connector for CDC-based replication, or rely on an automated ETL platform.

While manual and native options work in specific scenarios, they often require ongoing engineering effort to manage schema changes, retries, and monitoring. 

This is where a managed platform like Hevo fits naturally. Hevo automates MySQL to Snowflake replication, handles incremental loads and schema changes automatically, and provides built-in observability without manual scripts or maintenance.

For teams that want reliable, always-on syncs without operational overhead, Hevo offers a faster, lower-maintenance way to keep Snowflake in sync with MySQL, so you can focus on analytics, not pipelines.

Book a demo with Hevo to see how quickly you can set up a production-ready MySQL to Snowflake pipeline.

FAQ