Snowpipe Streaming
In shortSnowpipe Streaming lets an application send rows to a table through an SDK. In the high-performance architecture the rows pass through a PIPE object that can transform them. No file or stage is involved.
- Source
- Rows in an application, an IoT gateway or a Kafka topic
- Trigger
- The client sends rows through a channel
- Processor
- Snowflake serverless ingestion
- Destination
- A table, queryable within seconds
- Compute and billing
- High-performance: per uncompressed GB received · classic: serverless compute plus active client connections
The problem
Some sources never produce files. A Kafka topic emits rows continuously. Writing them to files only to load those files again adds delay and moving parts. Amine's real-time stock dashboard needs rows in seconds, not minutes.
How it works
The application uses a Snowflake SDK (or the Kafka connector) to send rows through a channel. A named channel keeps rows in order and tracks progress with offset tokens; an elastic channel is managed by Snowflake and doesn't guarantee order. Snowflake commits the rows and they become queryable within seconds. Two architectures exist. They differ in where the channel points and in how they're billed.
HIGH-PERFORMANCE · GA SEPTEMBER 2025 · billed per uncompressed GB received
SOURCEApp / Kafka v4rows in memory
CHANNELChannelordered rows
SERVER SIDEPIPE objecttransform, pre-cluster
TABLETablequeryable in seconds
CLASSIC · billed as serverless compute + active clients
SOURCEApp / KafkaIngest SDK client
insert rows
CHANNELChannelopened on the table
commit
TABLETablequeryable in seconds
The high-performance architecture became generally available in September 2025 (November 2025 on Azure and Google Cloud) and is the default choice for new projects. It counts only data values toward the GB measured, not structural bytes such as JSON keys.
The Kafka connector
The Snowflake Connector for Kafka runs in Kafka Connect, reads topics and writes them to Snowflake tables. Version 4, generally available since April 2026 and recommended for new deployments, writes through Snowpipe Streaming's high-performance architecture only. By default it creates one column per JSON key, and the Kafka metadata goes into a RECORD_METADATA VARIANT column when the table has one. The classic version 3 can load through Snowpipe (it stages files, then a pipe loads them) or through Snowpipe Streaming, and the tables it creates have two VARIANT columns: RECORD_CONTENT holds the message and RECORD_METADATA holds the topic, partition, offset and timestamp.
Choosing an ingestion path
| Bulk COPY | Snowpipe | Snowpipe Streaming | |
|---|---|---|---|
| Source | Files in a stage | Files in a stage | Rows in an application |
| Trigger | You run the statement (by hand, a task, an orchestrator) | Cloud event or REST call | The application sends rows |
| Processor | Your virtual warehouse | Snowflake serverless compute | Snowflake serverless ingestion |
| Destination | Table | Table | Table |
| Who pays for what | Warehouse credits per second while it runs | Credits per GB ingested | Per uncompressed GB (high-performance) or compute + clients (classic) |
| Typical latency | As often as you schedule it | Minutes | Seconds |
| Default on bad data | ABORT_ | SKIP_ | Errors reported per channel to the client |
| Load history | Table metadata, 64 days | Pipe metadata, 14 days | Offset tokens per named channel |
Rows through a channel, queryable in seconds, no stage. Serverless.
Files in a stage. Next: must they be loaded?
Query in place, read-only, warehouse at query time.
Load with COPY or Snowpipe. Next: when?
Event or REST call per file, serverless, billed per GB.
You run it (task, orchestrator); warehouse credits per second.
- Snowpipe Streaming ingests rows, not files; no stage is involved.
- Latency in seconds, versus minutes for Snowpipe.
- Both are serverless; neither uses your warehouse.
- Kafka connector tables: v3 gets RECORD_CONTENT and RECORD_METADATA (VARIANT); v4 gets one column per JSON key.

