Dates come in all shapes and sizes - Unix timestamps from event streams, weird looking numeric dates from legacy database exports, ISO 8601 strings from APIs, and more. Lucky for us, ClickHouse has a rich set of functions to handle all of them and that's what we're going to explore in this blog post.

We'll start with the most explicit approaches: converting Unix timestamps with `fromUnixTimestamp`, parsing packed numeric dates with `YYYYMMDDToDate`, and parsing known format strings with `parseDateTime`. Then we'll look at the `parseDateTimeBestEffort` family for when the format is unknown or mixed. 

Finally, we'll cover how casting dates with the `cast_string_to_date_time_mode` setting might be a better choice than explicit function calls for some use cases.

<iframe width="768" height="432" src="https://www.youtube.com/embed/hVEAzVz_xIY?si=-8QknStXsAO9iMjI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

## Unix timestamps {#unix_timestamps}

First up, Unix timestamps! Unix timestamps represent the number of seconds since January 1st, 1970. We can use the [`fromUnixTimestamp`](https://clickhouse.com/docs/en/sql-reference/functions/date-time-functions#fromUnixTimestamp) function to convert them:

<pre><code type='click-ui' language='sql' runnable='true'>
SELECT
    fromUnixTimestamp(1704067295) AS val1, toTypeName(val1);
</code></pre>

This returns a `DateTime` type. If you have milliseconds since January 1st, 1970, there's a different function — [`fromUnixTimestamp64Milli`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#fromUnixTimestamp64Milli) — and the type comes back as `DateTime64(3)`, where the `3` means precision up to milliseconds. 

<pre><code type='click-ui' language='sql' runnable='true'>
SELECT
    fromUnixTimestamp64Milli(1704067295123) AS val2, toTypeName(val2);
</code></pre>

For microseconds, [`fromUnixTimestamp64Micro`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#fromUnixTimestamp64Micro) returns `DateTime64(6)`:

<pre><code type='click-ui' language='sql' runnable='true'>
SELECT
    fromUnixTimestamp64Micro(1704067295123456) AS val3, toTypeName(val3);
</code></pre>

## Numeric date formats {#numeric_date_formats}

Sometimes dates are represented as plain numbers encoding the year, month, and day — with no separators or formatting. This is common in legacy database exports or flat files from mainframes. The function [`YYYYMMDDToDate`](https://clickhouse.com/docs/en/sql-reference/functions/date-time-functions#YYYYMMDDToDate) handles this:

<pre><code type='click-ui' language='sql' runnable='true'>
SELECT
    YYYYMMDDToDate(20240115) AS val1, toTypeName(val1);
</code></pre>

If the number also includes time information, [`YYYYMMDDhhmmssToDateTime`](https://clickhouse.com/docs/en/sql-reference/functions/date-time-functions#YYYYMMDDhhmmssToDateTime) handles that too:

<pre><code type='click-ui' language='sql' runnable='true'>
SELECT
    YYYYMMDDhhmmssToDateTime(20240115143022) AS val2, toTypeName(val2);
</code></pre>

## Known format strings {#known_format_strings}

APIs often return dates as strings. If you know the format, you can use [`parseDateTime`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#parseDateTime) with a MySQL date format string:

<pre><code type='click-ui' language='sql' runnable='true'>
SELECT
    parseDateTime('15/01/2024 14:30:22', '%d/%m/%Y %H:%i:%s') AS val1,
    toTypeName(val1);
</code></pre>

This returns a `DateTime` including the timezone. 

If you prefer Joda date format strings, there's [`parseDateTimeInJodaSyntax`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#parseDateTimeInJodaSyntax) which produces the same output:

<pre><code type='click-ui' language='sql' runnable='true'>
SELECT
    parseDateTimeInJodaSyntax('15/01/2024 14:30:22', 'dd/MM/yyyy HH:mm:ss') AS val2,
    toTypeName(val2);
</code></pre>

## Best effort parsing of DateTimes {#best_effort_parsing}

The previous three approaches all assumed we knew the exact date format. But what if we don't? That's where the [`parseDateTimeBestEffort`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#parseDateTimeBestEffort) family of functions comes in. Imagine we have dates in a mix of different formats:

<pre><code type='click-ui' language='sql' runnable='true'>
WITH dates AS (
    SELECT '2024-01-15T14:30:22.000Z' AS raw
    UNION ALL
    SELECT '2024-01-15' AS raw
    UNION ALL
    SELECT '1704067295' AS raw
)
SELECT raw, parseDateTimeBestEffort(raw) AS val, toTypeName(val)
FROM dates;
</code></pre>

We can also convert to `DateTime64` using [`parseDateTimeBestEffort64`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#parseDateTime64BestEffort), like the earlier functions:

<pre><code type='click-ui' language='sql' runnable='true'>
WITH dates AS (
    SELECT '2024-01-15T14:30:22.000Z' AS raw
    UNION ALL
    SELECT '2024-01-15' AS raw
    UNION ALL
    SELECT '1704067295' AS raw
)
SELECT raw, parseDateTime64BestEffort(raw) AS val, toTypeName(val)
FROM dates;
</code></pre>

What happens if we include a completely invalid date? 

<pre><code type='click-ui' language='sql' runnable='true'>
WITH dates AS (
    SELECT '2024-01-15T14:30:22.000Z' AS raw
    UNION ALL
    SELECT '2024-01-15' AS raw
    UNION ALL
    SELECT '1704067295' AS raw
    UNION ALL
    SELECT 'not a date' AS raw
)
SELECT raw, parseDateTime64BestEffort(raw) AS val, toTypeName(val)
FROM dates;
</code></pre>

ClickHouse throws an exception! 

We can work around this with the [`parseDateTimeBestEffort64OrNull`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#parseDateTime64BestEffortOrNull) variant, which returns `NULL` instead:

<pre><code type='click-ui' language='sql' runnable='true'>
WITH dates AS (
    SELECT '2024-01-15T14:30:22.000Z' AS raw
    UNION ALL
    SELECT '2024-01-15' AS raw
    UNION ALL
    SELECT '1704067295' AS raw
    UNION ALL
    SELECT 'not a date' AS raw
)
SELECT raw, parseDateTime64BestEffortOrNull(raw) AS val, toTypeName(val)
FROM dates;
</code></pre>

Or if you'd rather get an actual datetime value, [`parseDateTimeBestEffort64OrZero`](https://clickhouse.com/docs/en/sql-reference/functions/type-conversion-functions#parseDateTime64BestEffortOrZero) falls back to January 1st, 1970 at midnight:

<pre><code type='click-ui' language='sql' runnable='true'>
WITH dates AS (
    SELECT '2024-01-15T14:30:22.000Z' AS raw
    UNION ALL
    SELECT '2024-01-15' AS raw
    UNION ALL
    SELECT '1704067295' AS raw
    UNION ALL
    SELECT 'not a date' AS raw
)
SELECT raw, parseDateTime64BestEffortOrZero(raw) AS val, toTypeName(val)
FROM dates;
</code></pre>

## Casting {#casting}

If you'd rather avoid calling explicit parse functions throughout your queries, you can cast string values directly to date types using `::DateTime`. However, there's an important setting to be aware of: `cast_string_to_date_time_mode`.

By default it's set to `basic`, which handles standard formats like `YYYY-MM-DD` and `YYYY-MM-DD HH:MM:SS`, but anything else will fail. For broader format support, change it to `best_effort`. Note that this setting still throws an exception for completely invalid dates.

You can pass the setting inline per query:

<pre><code type='click-ui' language='sql' runnable='true'>
WITH dates AS (
    SELECT '2024-01-15T14:30:22.000Z' AS raw
    UNION ALL
    SELECT '2024-01-15' AS raw
    UNION ALL
    SELECT '1704067295' AS raw
)
SELECT raw, raw::DateTime AS val, toTypeName(val)
FROM dates
SETTINGS cast_string_to_date_time_mode = 'best_effort';
</code></pre>

Or configure it at the session level so you don't need it in every query:

<pre><code type='click-ui' language='sql'>
SET cast_string_to_date_time_mode = 'best_effort';
</code></pre>

Then the same query works without the `SETTINGS` clause:

<pre><code type='click-ui' language='sql'>
WITH dates AS (
    SELECT '2024-01-15T14:30:22.000Z' AS raw
    UNION ALL
    SELECT '2024-01-15' AS raw
    UNION ALL
    SELECT '1704067295' AS raw
)
SELECT raw, raw::DateTime AS val, toTypeName(val)
FROM dates;
</code></pre>

Finally, imagine that we have the following file that contains a variety of dates:

*dates.csv*
```csv
raw
2024-01-15T14:30:22.000Z
2024-01-15
1704067295
```

We can parse the dates in that file using the same approach:

<pre><code type='click-ui' language='sql'>
SELECT raw, raw::DateTime AS val, toTypeName(val)
FROM file('dates.csv', CSVWithNames);
</code></pre>

```shell
┌─raw──────────────────────┬─────────────────val─┬─toTypeName(val)─┐
│ 2024-01-15T14:30:22.000Z │ 2024-01-15 14:30:22 │ DateTime        │
│ 2024-01-15               │ 2024-01-15 00:00:00 │ DateTime        │
│ 1704067295               │ 2024-01-01 00:01:35 │ DateTime        │
└──────────────────────────┴─────────────────────┴─────────────────┘
```

Interested in seeing how ClickHouse works on your data? Get started with ClickHouse Cloud in minutes and receive $300 in free credits.

Get started today

5 Ways to Parse Dates and DateTimes in ClickHouse

large_Image 1920x1080.jpg

medium_Image 1920x1080.jpg

small_Image 1920x1080.jpg

thumbnail_Image 1920x1080.jpg

Image 1920x1080.jpg

5 ways to parse Dates and DateTimes in ClickHouse

Everything you need to know about ClickHouse as a geospatial analytics engine: its type system, indexing grids, strengths, and limitations.

large_Geospatial Blog Banner 2026.jpg

medium_Geospatial Blog Banner 2026.jpg

small_Geospatial Blog Banner 2026.jpg

thumbnail_Geospatial Blog Banner 2026.jpg

Geospatial Blog Banner 2026.jpg

State of Geospatial in ClickHouse in March 2026

One of my favorite features of ClickHouse 25.12 was the [`HMAC` function](https://clickhouse.com/blog/clickhouse-release-25-12#hmac) for message authentication using a shared key.

ClickHouse has always been able to act as a webhook endpoint, but with the HMAC function we can now verify webhook requests, filtering out those that didn't come from the expected source.
We'll start by seeing how this works with a local example, before moving onto a real-life example using ClickHouse Cloud as a GitHub webhook endpoint.

## The webhook pattern

One cool thing about ClickHouse is the ability to chain tables together using materialized views. Data gets ingested into one table, a materialized view acts as a SQL trigger, and the results are written to another table.

This becomes especially powerful when combined with the Null table engine. Rather than storing data, the Null table engine forwards
everything it receives to any connected materialized views — making it the perfect staging layer.

The result is a clean three-step pattern:
1. A staging table receives all incoming data
2. A materialized view validates and transforms it
3. A final table stores only the verified data

![Webhook Diagram Issue 1399.jpg](/uploads/Webhook_Diagram_Issue_1399_0e9e53eb69.jpg)

## Create the tables

Let's have a look at how to set this all up in ClickHouse.
If you want to follow along, you'll need to have a ClickHouse server or ClickHouse Cloud service running.

First, let's create the staging table:

<pre><code type='click-ui' language='sql'>
CREATE TABLE webhook_staging (
    received_at DateTime DEFAULT now(),
    raw_payload String,
    signature String DEFAULT getClientHTTPHeader('X-Hub-Signature-256')
) ENGINE = MergeTree()
ORDER BY received_at
SETTINGS allow_get_client_http_header=1;
</code></pre>

The `allow_get_client_http_header` setting is required because reading client headers is disabled by default.

> We're creating the `webhook_staging` table with the `MergeTree` engine, so that we can debug incoming requests. In a production system we would use the `Null` engine and might also have a second materialized view that captures invalid requests.

Next, we have a table that's going to store only verified rows:

<pre><code type='click-ui' language='sql'>
CREATE TABLE webhook_logs (
    received_at DateTime,
    payload JSON
) ENGINE = MergeTree()
ORDER BY received_at;
</code></pre>

And finally, we have a materialized view that validates the data:

<pre><code type='click-ui' language='sql'>
CREATE MATERIALIZED VIEW webhook_validator TO webhook_logs AS
SELECT
    received_at,
    raw_payload::JSON as payload
FROM webhook_staging
WHERE signature = 'sha256=' || lower(hex(HMAC('SHA256', raw_payload, 'my_secret_key')));
</code></pre>

We're comparing the signature from the request header to the expected signature computed using the shared secret key.
Our shared secret key is `my_secret_key`.

If the incoming row doesn't match the expected signature, it won't be written to the `webhook_logs` table.

## Create a restricted user

When experimenting on our own machine, we could use the default admin user, but for a production system it's safer to create a dedicated user with minimal permissions.
The user that we create will be used in the webhook URL that we construct later.

First, let's create the user:

<pre><code type='click-ui' language='sql'>
CREATE USER webhook_receiver
IDENTIFIED WITH sha256_hash
BY 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
</code></pre>

The hash is the SHA256 of an empty string, so no password is needed when we construct the webhook URL.

Next, let's grant the user the permissions it needs:

<pre><code type='click-ui' language='sql'>
GRANT INSERT ON default.webhook_staging TO webhook_receiver;
GRANT SELECT ON default.webhook_staging TO webhook_receiver;
GRANT SHOW TABLES ON default.webhook_staging TO webhook_receiver;
GRANT SHOW DATABASES ON default.* TO webhook_receiver;
</code></pre>

If we want to be extra cautious, we could also apply rate limits to this user to guard against abuse.

## Construct the webhook URL

ClickHouse accepts inserts over HTTP, which means the whole webhook endpoint is a URL with the INSERT query embedded:

```
http://localhost:8123/?user=webhook_receiver&query=INSERT+INTO+webhook_staging+(raw_payload)+FORMAT+RawBLOB
```

The key parts:
- `user=webhook_receiver` -the restricted user we created
- `query=INSERT INTO webhook_staging (raw_payload) FORMAT RawBLOB` -the URL-encoded query that inserts the raw request body

`FORMAT RawBLOB` tells ClickHouse to treat the entire request body as a single string value rather than trying to parse it.

We can then test it out by sending a valid request i.e. one where the signature is computed with the correct key:

<pre><code type='click-ui' language='bash'>
PAYLOAD='{"event":"user_login","user_id":456}'
SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "my_secret_key" | cut -d' ' -f2)

curl -X POST "http://localhost:8123/?user=webhook_receiver&allow_get_client_http_header=1&query=INSERT%20INTO%20webhook_staging%20(raw_payload)%20FORMAT%20RawBLOB" \
  -H "X-Hub-Signature-256: sha256=$SIGNATURE" \
  -d "$PAYLOAD"
</code></pre>

Let's now connect to our ClickHouse Server using ClickHouse Client:

<pre><code type='click-ui' language='bash'>
clienthouse client
</code></pre>

And we can return the contents of `webhook_staging` and `webhook_logs`:

<pre><code type='click-ui' language='sql'>
SELECT * FROM webhook_staging;
</code></pre>

```shell
Row 1:
──────
received_at: 2026-02-20 15:42:22
raw_payload: {"event":"user_login","user_id":456}
signature:   sha256=5a23c796b6248c725a6ec7fc2cf0788117d69d376ee6241f411a8887297d3ca4

1 row in set. Elapsed: 0.001 sec.
```

<pre><code type='click-ui' language='sql'>
SELECT * FROM webhook_logs;
</code></pre>

```shell
Row 1:
──────
received_at: 2026-02-20 15:42:22
payload:     {
    "event": "user_login",
    "user_id": 456
}

1 row in set. Elapsed: 0.003 sec.
```

Both tables have the data. Now how about we send a request where we've computed the signature with a different key:

<pre><code type='click-ui' language='bash'>
PAYLOAD='{"event":"user_login","user_id":456}'
SIGNATURE=$(echo -n "$PAYLOAD" | openssl dgst -sha256 -hmac "rogue_key" | cut -d' ' -f2)

curl -X POST "http://localhost:8123/?user=webhook_receiver&allow_get_client_http_header=1&query=INSERT%20INTO%20webhook_staging%20(raw_payload)%20FORMAT%20RawBLOB" \
  -H "X-Hub-Signature-256: sha256=$SIGNATURE" \
  -d "$PAYLOAD"
</code></pre>

Let's run our queries against `webhook_staging`:


```shell
Row 1:
──────
received_at: 2026-02-20 15:43:21
raw_payload: {"event":"user_login","user_id":456}
signature:   sha256=01f65041f2505f2b245f3caff410913a22a0ff8c7e8414c9fe1e861359973a7a

Row 2:
──────
received_at: 2026-02-20 15:42:22
raw_payload: {"event":"user_login","user_id":456}
signature:   sha256=5a23c796b6248c725a6ec7fc2cf0788117d69d376ee6241f411a8887297d3ca4

2 rows in set. Elapsed: 0.002 sec.
```

And now, `webhook_logs`:

```shell
Row 1:
──────
received_at: 2026-02-20 15:42:22
payload:     {
    "event": "user_login",
    "user_id": 456
}

1 row in set. Elapsed: 0.004 sec.
```

`webhook_staging` gets a new row, `webhook_logs` doesn't  - the signatures didn't match so the materialized view dropped it.

## GitHub webhook

With the pattern established locally, let's wire it up to a real GitHub repository using ClickHouse Cloud. The structure is almost identical, with just one difference - the staging table picks up an extra `event_type` column (from the `X-GitHub-Event` header GitHub sends) and `webhook_logs` picks an `event_type` column as well.

<iframe width="768" height="432" src="https://www.youtube.com/embed/9-2N58cZhoQ?si=acW0rRIHSWrjRHBg" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>


The queries below create our tables and materialized view.

<pre><code type='click-ui' language='sql'>
CREATE TABLE webhook_staging (
    received_at DateTime DEFAULT now(),
    raw_payload String,
    event_type String DEFAULT getClientHTTPHeader('X-GitHub-Event'),
    signature String DEFAULT getClientHTTPHeader('X-Hub-Signature-256')
) ENGINE = MergeTree()
ORDER BY received_at
SETTINGS allow_get_client_http_header=1;
</code></pre>

<pre><code type='click-ui' language='sql'>
CREATE TABLE webhook_logs (
    received_at DateTime,
    event_type String,
    payload JSON
) ENGINE = MergeTree()
ORDER BY received_at;
</code></pre>

<pre><code type='click-ui' language='sql'>
CREATE MATERIALIZED VIEW webhook_validator TO webhook_logs AS
SELECT
    received_at,
    event_type,
    raw_payload::JSON as payload
FROM webhook_staging
WHERE signature = 'sha256=' || lower(hex(HMAC('SHA256', raw_payload, 'my_secret_key')));
</code></pre>

In ClickHouse Cloud, click **Connect** to get your cluster URL, then build the webhook URL the same way - just swap `localhost:8123` for your Cloud host and add `allow_get_client_http_header=1`:

```
https://<host>:8443/?user=webhook_receiver&allow_get_client_http_header=1&query=INSERT+INTO+webhook_staging+(raw_payload)+FORMAT+RawBLOB
```

### Configure the GitHub webhook

In your GitHub repository, go to **Settings → Webhooks → Add webhook**:

1. Paste your ClickHouse URL into **Payload URL**
2. Set **Content type** to `application/json`
3. Enter your secret key in the **Secret** field -this must match `my_secret_key` from the materialized view
4. Choose which events to send (push events are fine to start)
5. Click **Add webhook**

![2026-02-20_15-48-01.png](/uploads/2026_02_20_15_48_01_9837c2f742.png)

GitHub will immediately send a `ping` event. Refresh the webhook page and you should see "Last delivery was successful".

![2026-02-20_15-48-31.png](/uploads/2026_02_20_15_48_31_e808d6d9c3.png)

### Verify it's working

We can then explore the contents of each table by clicking their name.

You should see the `ping` event in both, which confirms the HMAC validation passed. Now make a change to your repository -commit to a branch, open a PR, merge it -and push events will appear in both tables.

![2026-02-20_16-11-08.png](/uploads/2026_02_20_16_11_08_fbcc3df256.png)

### Testing signature validation

To confirm the validation is working, go back to GitHub, change the webhook secret to something different, then make another commit.

`webhook_staging` will have the new rows but `webhook_logs` won't - the materialized view computed a different HMAC and filtered them out.

![Webhook Diagram for Blog.jpg](/uploads/Webhook_Diagram_for_Blog_ae59da5240.jpg)

Ready to create your own webhook endoint?

Using ClickHouse as a webhook endpoint with HMAC verification

large_YouTube Thumbnail ClickHouse Issue 1394.jpg

medium_YouTube Thumbnail ClickHouse Issue 1394.jpg

small_YouTube Thumbnail ClickHouse Issue 1394.jpg

thumbnail_YouTube Thumbnail ClickHouse Issue 1394.jpg

YouTube Thumbnail ClickHouse Issue 1394.jpg


Hello, and welcome to the February 2026 ClickHouse newsletter!

This month, we have ClickHouse’s $400M Series D, the release of the official Kubernetes operator, a data modelling guide, how ClickHouse optimizes Top-N queries, and more!

## Featured community member: Ino de Bruijn {#featured-community-member}

This month's featured community member is Ino de Bruijn, Data Visualization Team Lead at Memorial Sloan Kettering Cancer Center's Cancer Data Science Initiative.  

![](/uploads/feb2026_nl_image1_a784b3580c.png)

Ino leads a team of engineers building software tools for cancer research, visualizing and disseminating data from major consortia including HTAN, Break Through Cancer, AACR GENIE, and the Gray BRCA Pre-Cancer Atlas. 

For nearly 11 years, he's also been instrumental in developing cBioPortal - the most popular cancer genomics tool worldwide, with over 3,000 daily users and more than 25,000 citations.

At the ClickHouse New York Meetup in December, [Ino presented on his team's work](https://clickhouse.com/videos/nymeetupdec82025) building a conversational AI interface for cBioPortal using ClickHouse, Anthropic's Claude, and LibreChat - a fully open-source solution making cancer research data more accessible to researchers and clinicians.

➡️ [Connect with Ino on LinkedIn](https://www.linkedin.com/in/inodb/)

## Upcoming events {#upcoming-events}

### Global virtual events

* [v26.1 Community Call](https://clickhouse.com/company/events/v25-12-community-release-call) - 26th February   
* [CDC ClickPipes: The Fastest Way to Replicate Your Database to ClickHouse](https://clickhouse.com/company/events/202602-APJ-Webinar-CDC-ClickPipes) - 26th February  
* [Under-the-Hood: ClickHouse Incremental Materialized Views and Dictionaries](https://clickhouse.com/company/events/202602-EMEA-Webinar-Materialized-Views) - 4th March

### Virtual training

* [ClickHouse Query Optimization Workshop](https://clickhouse.com/company/events/202602-amer-emea-query-optimization) - 19th February  
* [chDB: Data Analytics with ClickHouse and Python](https://clickhouse.com/company/events/202603-AMER-EMEA-chDB:Data-Analytics-with-ClickHouse-and-Python) - 18th March  
* [Real-time Analytics with ClickHouse](https://clickhouse.com/company/events/202603-AMER-Real-time-Analytics-w-ClickHouse) - 5th March

**Data Warehousing**

* [Data Warehousing with ClickHouse: Level 2](https://clickhouse.com/company/events/202602-AMER-data-warehousing-Level2) - 25th February  
* [Data Warehousing with ClickHouse: Level 1](https://clickhouse.com/company/events/202603-APJ-data-warehousing-Level1) - 3rd March  
* [Data Warehousing with ClickHouse: Level 2](https://clickhouse.com/company/events/202603-APJ-data-warehousing-Level2) - 4th March  
* [Data Warehousing with ClickHouse: Level 3](https://clickhouse.com/company/events/202603-APJ-data-warehousing-Level3) - 5th March

### Events in AMER

* [Toronto Meetup](https://www.meetup.com/clickhouse-toronto-user-group/events/312881151/?slug=clickhouse-toronto-user-group&eventId=310164482&isFirstPublish=true) - 19th February  
* [Seattle Meetup](https://luma.com/jsctpwoa) - 26th February  
* [LA Meetup](https://luma.com/wbkqmaqk) - 6th March   
* [Atlanta In-person Training: Real-time Analytics with ClickHouse](https://clickhouse.com/company/events/202603-AMER-Atlanta-Real-time-Analytics-w-ClickHouse) - 5th March

### Events in EMEA

* [ClickHouse Meetup in Tbilisi Georgia](https://www.meetup.com/clickhouse-georgia-meetup-group/events/312852206/) - 24th February

### Events in APAC

* [ClickHouse Melbourne Meetup](https://clickhouse.com/company/events/202602-APJ-Melbourne-Meetup) - 24th February  
* [Dink & Data: Executive Pickleball Social, Singapore](https://clickhouse.com/company/events/202602-APJ-Singapore-DinkDataHappyHour) - 25th February  
* [Webinar: CDC ClickPipes: The Fastest Way to Replicate Your Database to ClickHouse](https://clickhouse.com/company/events/202602-APJ-Webinar-CDC-ClickPipes) - 26th February  
* [ClickHouse + GDG + Deutsche Bank Bangalore Meetup](https://www.meetup.com/clickhouse-bangalore-user-group/events/313325219/) - 28th February  
* [ClickHouse Tokyo Meetup - LibreChat Night](https://www.meetup.com/clickhouse-tokyo-user-group/events/313275265/) - 9th March  
* [Data Streaming World Melbourne](https://clickhouse.com/company/events/202603-APJ-3PC-Melbourne-DataStreamingWorld) - 5th March  
* [Hackomania Singapore](https://hackomania.geekshacking.com/) - 7th - 8th March  
* [PGConf India](https://pgconf.in/conferences/pgconfin2026) - 11th - 13th March  
* [AWS Unicorn Day 2026 Seoul](https://clickhouse.com/company/events/202603-APJ-3PC-Seoul-AWSUnicornDay) - 17th March  
* [Python Asia 2026](https://2026.pythonasia.org/) - 21st - 23rd March

## 26.1 release {#release}

![](/uploads/feb2026_nl_image6_adff8e72ed.png)

The first release of 2026 adds support for the sparseGrams tokenizer to the text index, which also now supports arrays of Strings or FixedStrings.

There’s support for the Variant data type in all functions, new syntax for indexing projections, deduplication of asynchronous inserts with materialized views, and more!

➡️ [Read the release post](https://clickhouse.com/blog/clickhouse-release-26-01)

## ClickHouse raises $400M Series D, acquires Langfuse, and launches Postgres {#series_d}

![](/uploads/feb2026_nl_image7_c50bd14a9f.png)

ClickHouse closed a $400 million Series D funding round led by Dragoneer Investment Group, with participation from Bessemer Venture Partners, GIC, Index Ventures, Khosla Ventures, Lightspeed Venture Partners, T. Rowe Price Associates, and WCM Investment Management.

Alongside the funding announcement, ClickHouse [acquired Langfuse](https://clickhouse.com/blog/clickhouse-acquires-langfuse-open-source-llm-observability), an open-source LLM observability platform with over 20K GitHub stars and more than 26M+ SDK installs per month. Additionally, ClickHouse launched [an enterprise-grade PostgreSQL service](https://clickhouse.com/blog/postgres-managed-by-clickhouse) integrated with its platform.

➡️ [Read the blog post](https://clickhouse.com/blog/clickhouse-raises-400-million-series-d-acquires-langfuse-launches-postgres)

## Provable Completeness:  Guaranteeing Zero Data Loss in Trade Collection from Crypto Exchanges {#provable_completeness}

![](/uploads/feb2026_nl_image9_6dde790b1e.png)

Unreliable WebSocket connections and network interruptions create a persistent challenge to data quality in cryptocurrency market data collection. Koinju, a crypto platform built for finance professionals, ingests millions of trades per day across hundreds of markets. For their clients, even a single missing trade can distort volumes, P&L calculations, risk exposures, and regulatory reports - making data completeness non-negotiable.

In this blog post, Dmitry Prokofyev, CTO of Koinju, describes a novel solution using only ClickHouse to detect and automatically remediate missing trades from Coinbase. The architecture combines three ClickHouse features to create a self-healing system: Refreshable Materialized Views for detection, a separate validation service for REST API backfilling, and ReplacingMergeTree for automatic deduplication of resolved gaps.

➡️ [Read the blog post](https://koinju.io/blog/provable-completeness-how-we-achieve-zero-data-loss-in-trade-collection-from-crypto-exchanges)

## Introducing the Official ClickHouse Kubernetes Operator: Seamless Analytics at Scale {#kubernetes_operator}

![](/uploads/feb2026_nl_image5_891092f82b.png)

Grisha Pervakov introduces ClickHouse's official open-source Kubernetes Operator, designed to simplify the deployment and management of ClickHouse clusters on Kubernetes.

The operator enables rapid provisioning of production-ready clusters with built-in sharding and replication capabilities while eliminating the need for separate ZooKeeper installations by using ClickHouse Keeper for cluster coordination. 

➡️ [Read the blog post](https://clickhouse.com/blog/clickhouse-kubernetes-operator)

## AI-Generated analytics without wrecking your cluster {#ai_generated_analytics}

![](/uploads/feb2026_nl_image4_f4c62f344a.png)

Luke from Faster Analytics Fridays outlines three guardrail patterns for safely enabling AI-generated database queries without crashing clusters: 

1. Using pre-vetted query templates with parameter binding instead of raw SQL generation  
2. Exposing curated materialized views rather than raw tables, and   
3. Enforcing query budgets that validate estimated row scans and execution time before queries hit the database.

➡️ [Read the blog post](https://www.newsletter.hypequery.com/p/ai-generated-analytics-without-wrecking-your-cluster)

## Data modeling guide for real-time analytics with ClickHouse {#data_modeling_guide}

![](/uploads/feb2026_nl_image3_0addcbc0a4.png)

Simon Späti has written a comprehensive guide to designing optimized data models in ClickHouse for sub-second real-time analytics, emphasizing that performance comes from shifting computational work from query time to insertion time. 

The article covers core principles, including denormalization to minimize joins, partitioning by time and secondary dimensions for query pruning, and predicate pushdown optimization that moves filters closer to data sources. 

➡️ [Read the blog post](https://www.ssp.sh/blog/practical-data-modeling-clickhouse/)

## PostgreSQL + ClickHouse as the Open Source unified data stack {#postgres_clickhouse}

![](/uploads/feb2026_nl_image2_90bf827bd5.png)  
Lionel Palacin introduces an open-source unified data stack that combines PostgreSQL for transactional workloads with ClickHouse for analytics. 

It uses PeerDB for near-real-time CDC replication and the pg_clickhouse extension for transparent query offloading without rewriting SQL, enabling teams to start with PostgreSQL and add ClickHouse when analytical performance becomes critical.

➡️ [Read the blog post](https://clickhouse.com/blog/postgres-clickhouse-oss)

## Quick reads {#quick-reads}

* Mikhail Zharkov describes [building a scalable price distribution pipeline for trading systems using ClickHouse](https://mikhail-zharkov.medium.com/price-server-0b4da9d38f29).  
* Abhinaav Ramesh [built Ollama-Local-Serve](https://medium.com/@contactabhinaav/building-a-self-hosted-llm-server-youll-actually-use-dae13111447a), a self-hosted LLM server with complete observability, using ClickHouse for time-series analytics, OpenTelemetry instrumentation, FastAPI monitoring APIs, and a React dashboard with streaming chat.  
* Pranav Mehta describes [investigating ClickHouse connection retry warnings](https://medium.com/@pranavmehta94/clickhouse-internals-a-deep-dive-into-clickhouse-distributed-connection-pooling-d9e956b5eb57) in an on-prem environment that initially appeared to be a critical connection leak but turned out to be expected behavior when the connection pool attempts to reuse stale connections after idle periods.  
* Lionel Palacin [redesigned the data pipeline of ClickPy](https://clickhouse.com/blog/clickpy-2-trillion-rows), a ClickHouse-backed service that contains 2.2 trillion rows of Python package analytics. Data was previously ingested using custom batch scripts but has been migrated to ClickPipes and uses ClickHouse's lightweight deletes to correct historical data without rebuilding the entire dataset.  
* Tom Schreiber explains [how ClickHouse optimizes Top-N queries](https://clickhouse.com/blog/clickhouse-top-n-queries-granule-level-data-skipping) using granule-level data skipping with min/max metadata filtering, achieving 5-10× speedup and 10-100× reduction in data processed.


Welcome to the February 2026 ClickHouse newsletter, which will round up what’s happened in real-time data warehouses over the last month.

large_feb2026_nl_image8.png

medium_feb2026_nl_image8.png

small_feb2026_nl_image8.png

thumbnail_feb2026_nl_image8.png

feb2026_nl_image8.png

February 2026 newsletter

Hello, and welcome to the January 2026 ClickHouse newsletter!

This month, we learn how chDB achieved true zero-copy integration with Pandas DataFrames, how WKRP migrated their RuneScape tracking plugin from TimescaleDB to ClickHouse, replacing Apache Flink with ClickHouse's Kafka engine, and more!

## Featured community member: lgbo {#featured-community-member}

This month's featured community member is lgbo.

![jan20026_image5.png](/uploads/jan20026_image5_7e4ba288f9.png)

lgbo works at BIGO, where they use ClickHouse in their real-time data pipeline that processes tens of billions of messages daily.

lgbo has submitted several pull requests to address performance issues, including reducing memory usage for window functions, reducing cache misses during hash table iteration, and optimizing CROSS JOINs.

lgbo also improved short-circuit execution performance by avoiding unnecessary operations on non-function columns, added a new stringCompare function for lexicographic comparison of substring portions, and fixed a bug where named tuple element names weren't preserved correctly during type derivation.

➡️ <a href="https://github.com/lgbo-ustc" target="_blank">Follow lgbo on GitHub</a>

## 25.12 release {#release}

![jan20026_image6.png](/uploads/jan20026_image6_a0edc2e602.png)

ClickHouse 25.12 delivers significant improvements in query performance across the board. We have faster top-N queries through data skipping indexes, a reimagined lazy reading execution model that's 75 times faster, and a more powerful DPsize join reordering algorithm.

➡️ <a href="https://clickhouse.com/blog/clickhouse-release-25-12" target="_blank">Read the release post</a>

## The Journey to Zero-Copy: How chDB Became the Fastest SQL Engine on Pandas DataFrame {#chdb}

![jan20026_image7.png](/uploads/jan20026_image7_1d3f81a67a.png)

chDB v4.0 achieves true zero-copy integration with Pandas DataFrames. By eliminating serialization steps and implementing direct memory sharing between ClickHouse and NumPy, queries that previously took 30 seconds now complete in under a second.

➡️ <a href="https://clickhouse.com/blog/chdb-journey-to-zero-copy" target="_blank">Read the blog post</a>

## A small-time review of ClickHouse {#clickhouse_review}

WKRP migrated their RuneScape tracking plugin from TimescaleDB to ClickHouse with impressive results. Storage usage improved dramatically: location data compressed from 4.28 GiB to 592 MiB (87% reduction), while XP tracking data went from 872 MiB to 168 MiB (81% reduction). Beyond storage, the migration simplified operations - upgrades now happen through the package manager without coordinated downtime.

The verdict: "Timescale worked well, but ClickHouse has provided better performance and made running the service easier."

➡️ <a href="https://www.wkrp.xyz/a-small-time-review-of-clickhouse/" target="_blank">Read the blog post</a>

## Solving the "Impossible" in ClickHouse: Advent of Code 2025 {#advent_of_code}

![jan20026_image1.png](/uploads/jan20026_image1_245b4653d7.png)

Yes, we're still talking about Christmas in mid-January, but Zach Naimon's deep dive into solving Advent of Code 2025 entirely in ClickHouse SQL is worth the delayed celebration.

Following strict rules (pure SQL only, raw inputs, single queries), Zach tackled all 12 algorithmic puzzles that typically require Python, Rust, or C++. The solutions showcase ClickHouse's versatility through recursive CTEs for pathfinding, arrayFold for state machines, and specialized functions like intervalLengthSum for geometric problems.

Proof that with the right tools, "impossible" problems become just another data challenge.

➡️ <a href="https://clickhouse.com/blog/clickhouse-advent-of-code-2025" target="_blank">Read the blog post</a>

## Seven Companies, One Pattern: Why Every Scaled ClickHouse Deployment Looks the Same {#seven_companies}

Luke Reilly explains why Uber, Cloudflare, Instacart, GitLab, Lyft, Microsoft, and Contentsquare all build the same four-layer abstraction stack over ClickHouse: it changes cost curves.

Platform teams absorb schema optimization knowledge once through semantic layers and query translation engines, enabling sublinear scaling - headcount grows with data volume instead of user count.

Now AI is becoming the fifth layer, with tools like ClickHouse.ai and MCP servers adding natural language interfaces on top of these semantic definitions.

➡️ <a href="https://medium.com/@lureilly1/seven-companies-one-pattern-why-every-scaled-clickhouse-deployment-looks-the-same-d2ba68606ad6" target="_blank">Read the blog post</a>

## Your AI SRE needs better observability, not bigger models {#ai_sre}

![jan20026_image2.png](/uploads/jan20026_image2_f3bbf2f869.png)

Drawing on his experience increasing Confluent's availability from 99.9% to 99.95%, Manveer Chawla explains why AI SRE copilots should prioritize investigation over auto-remediation. Most AI SRE tools fail because they're built on observability platforms with short retention, dropped high-cardinality dimensions, and slow queries.

The solution? Rethink the observability architecture. Manveer details a reference architecture using ClickHouse that demonstrates the effectiveness of AI copilots, which require better data foundations, rather than larger models.

➡️ <a href="https://clickhouse.com/blog/ai-sre-observability-architecture" target="_blank">Read the blog post</a>

## Simplifying real-time data pipelines: How ClickHouse replaced Flink for our Kafka Streams {#kafka_streams}

![jan20026_image4.png](/uploads/jan20026_image4_df92d08407.png)

Ashkan Goleh Pour provides a detailed walkthrough of replacing Apache Flink with ClickHouse's native Kafka integration for real-time streaming.

The architecture uses ClickHouse's Kafka table engine to consume events directly, Materialized Views for continuous SQL transformations, and MergeTree tables for persistent state, thereby eliminating the need for external stream processors.

➡️ <a href="https://medium.com/towards-data-engineering/simplifying-real-time-data-pipelines-how-clickhouse-replaced-flink-for-our-kafka-streams-13f6f4e1e097" target="_blank">Read the blog post</a>

## Quick reads {#quick-reads}

* Georgii Baturin has written a multi-part series of posts showing <a href="https://medium.com/hands-on-dbt-with-clickhouse/hands-on-dbt-with-clickhouse-7-why-tests-matter-and-why-a-green-build-does-not-prove-anything-by-c15f1cb1264d" target="_blank">how to use dbt with ClickHouse</a>.
* Shuva Jyoti Kar demonstrates <a href="https://medium.com/@shuva.jyoti.kar.87/the-speed-of-thought-real-time-analytics-meets-agentic-ai-1864e1ed6165" target="_blank">how to build an autonomous AI agent system</a> by connecting ClickHouse with Google's Gemini CLI using the Model Context Protocol (MCP).
* Gulled Hayder shows <a href="https://medium.com/@aagulled/getting-clickhouse-ready-for-web-traffic-analysis-6bec9867e1ee" target="_blank">how to set up ClickHouse on a Linux system</a> with Python, install and configure the database with proper authentication, generate 1 million rows of synthetic web traffic data, and load it into a MergeTree table for analytics.
* ByteBoss [builds a real-time cryptocurrency market data pipeline](https://medium.com/@ByteBosss/building-a-real-time-cryptocurrency-market-data-pipeline-from-scratch-9c81acf3f75b) that connects to exchange WebSockets (Binance/Coinbase), normalizes their different data formats, streams through Kafka/Redpanda, automatically processes with ClickHouse materialized views, and visualizes live trading data in Grafana dashboards.

## Interesting projects {#interesting-projects}

* <a href="https://github.com/arniwesth/DoomHouse" target="_blank">DoomHouse</a> - An experimental "Doom-like" game engine that renders the 3D graphics entirely in ClickHouse SQL.
* <a href="https://hub.docker.com/r/genezhang/clickgraph" target="_blank">genezhang/clickgraph</a> - Stateless, read-only graph query engine for ClickHouse using Cypher.
* <a href="https://github.com/ppiankov/clickspectre" target="_blank">clickspectre</a> - A spectral ClickHouse analyzer that tracks which tables are actually used and by whom.

## Upcoming events {#upcoming-events}

### Virtual training

* <a href="https://clickhouse.com/company/events/202602-amer-clickhouse-admin-workshop" target="_blank">ClickHouse Admin Workshop</a> - 12th February
* <a href="https://clickhouse.com/company/events/202602-amer-emea-query-optimization" target="_blank">ClickHouse Query Optimization Workshop</a> - 19th February

**Real-time Analytics**

* <a href="https://clickhouse.com/company/events/202601-EMEA-Real-time-Analytics-with-ClickHouse-Level2" target="_blank">Real-time Analytics with ClickHouse: Level 2</a> - 21st January
* <a href="https://clickhouse.com/company/events/202601-EMEA-Real-time-Analytics-with-ClickHouse-Level3" target="_blank">Real-time Analytics with ClickHouse: Level 3</a> - 28th January

**Observability**

* <a href="https://clickhouse.com/company/events/202601-APJ-Observability-with-ClickStack-Level1" target="_blank">Observability with ClickStack: Level 1</a> (APJ time) - 27th January
* <a href="https://clickhouse.com/company/events/202601-APJ-Observability-with-ClickStack-Level2" target="_blank">Observability with ClickStack: Level 2</a> (APJ time) - 29th January
* <a href="https://clickhouse.com/company/events/202602-AMER-Observability-with-ClickStack-Level1" target="_blank">Observability with ClickStack: Level 1</a> - 4th February
* <a href="https://clickhouse.com/company/events/202602-AMER-Observabiity-with-ClickStackLevel2" target="_blank">Observability with ClickStack: Level 2</a> - 5th February

### Events in AMER

* <a href="https://luma.com/abggijbh" target="_blank">Iceberg Meetup in Menlo Park</a> - 21st January
* <a href="https://luma.com/ifxnj82q" target="_blank">Iceberg Meetup in NYC</a> - 23rd January
* <a href="https://luma.com/iicnlq41" target="_blank">New York Meetup</a> - 26th January
* <a href="https://clickhouse.com/company/events/webinar-true-cost-of-speed" target="_blank">The True Cost of Speed: What Query Performance Really Costs at Scale</a> - 3rd February
* <a href="https://luma.com/j2ck1sbz" target="_blank">AI Night SF</a> - 11th February
* <a href="https://www.meetup.com/clickhouse-toronto-user-group/events/312881151/?slug=clickhouse-toronto-user-group&eventId=310164482&isFirstPublish=true" target="_blank">Toronto Meetup</a> - 19th February
* <a href="https://luma.com/jsctpwoa" target="_blank">Seattle Meetup</a> - 26th February
* <a href="https://luma.com/wbkqmaqk" target="_blank">LA Meetup</a> - 6th March

### Events in EMEA

* <a href="https://luma.com/3szhmv9h" target="_blank">Data & AI Paris Meetup</a> - 22nd January
* <a href="https://clickhouse.com/company/events/agentic-data-stack-ams" target="_blank">The Agentic Data Stack: The Future is Conversational</a> (Amsterdam) - 27th January
* <a href="https://clickhouse.com/company/events/202601-EMEA-Paris-meetup" target="_blank">ClickHouse Meetup in Paris</a> - 28th January
* <a href="https://luma.com/yx3lhqu9" target="_blank">Apache Iceberg™ Meetup Belgium: FOSDEM Edition</a> - 30th January
* <a href="https://luma.com/czvs584m" target="_blank">FOSDEM Community Dinner Brussels</a> - 31st January
* <a href="https://clickhouse.com/company/events/202602-EMEA-Barcelona-meetup" target="_blank">ClickHouse Meetup in Barcelona</a> - 5th February
* <a href="https://clickhouse.com/company/events/202602-EMEA-London-meetup" target="_blank">ClickHouse Meetup in London</a> - 10th February
* <a href="https://www.meetup.com/clickhouse-georgia-meetup-group/events/312852206/" target="_blank">ClickHouse Meetup in Tbilisi Georgia</a> - 24th February

### Events in APAC

* <a href="https://clickhouse.com/company/events/202601-APJ-Singapore-Meetup" target="_blank">ClickHouse Singapore Meetup</a> - 27th January
* <a href="https://clickhouse.com/company/events/202601-APJ-Real-time-Analytics-w-ClickHouse" target="_blank">Boot Camp: Real-time Analytics with ClickHouse</a> - 27th January
* <a href="https://clickhouse.com/company/events/202601-apj-seoul-meetup" target="_blank">ClickHouse Seoul Meetup</a> - 29th January

### Speaking at ClickHouse meetups

Want to speak at a ClickHouse meetup? <a href="https://docs.google.com/forms/d/e/1FAIpQLSdpYbh0k3hmLOQ7JLXrubvEbiIul4TxJDp1AVewXHSdzHcmzA/viewform" target="_blank">Apply here!</a>

Below are some upcoming call for papers (CFPs):

* <a href="https://sessionize.com/iceberg-summit-2026/" target="_blank">Iceberg Summit SF</a> - April 6-8
* <a href="https://aicouncil.com/apply-to-speak" target="_blank">AI Council SF</a> - May 12-14
* <a href="https://sessionize.com/observability-summit-2026" target="_blank">Observability Summit Minneapolis</a>  - May 21-22
* <a href="https://events.linuxfoundation.org/kubecon-cloudnativecon-india/program/cfp/" target="_blank">Kubecon India Mumbai</a> - June 18-19
* <a href="https://pretalx.com/grafanacon-2026/cfp" target="_blank">GrafanaCon Barcelona</a> - April 20-22
* <a href="https://sessionize.com/wearedevelopers-world-congress-2026-europe" target="_blank">We Are Developers Berlin</a> - July 8-10


Welcome to the January 2026 ClickHouse newsletter, which will round up what’s happened in real-time data warehouses over the last month.

large_jan20026_image3.png

medium_jan20026_image3.png

small_jan20026_image3.png

thumbnail_jan20026_image3.png

jan20026_image3.png

January 2026 newsletter

Over 100 functions were added to ClickHouse in 2025. These were some of my favorites.

Mark Needham

Blog posts by Mark Needham

5 ways to parse Dates and DateTimes in ClickHouse

State of Geospatial in ClickHouse in March 2026

Using ClickHouse as a webhook endpoint with HMAC verification

February 2026 newsletter

January 2026 newsletter

New functions you might have missed in 2025