TSBS IoT · Reproducible harness
Arc vs TDengine
The same TSBS IoT data and the same queries at 10,000 and 100,000 tags, with the same row counts from both engines. With one setting, Arc keeps the data up to 47% smaller in open Parquet and ingests it faster with every write on disk; it runs aggregations over history up to 6.5x faster. TDengine answers latest-value lookups per device faster. Every number is reproducible.
Storage with ingest.sort_keys on fleet and truck (25% smaller as shipped). Aggregation as shipped (6.3x with sort keys).
What was tested
- Arc built from main at
0080aa31, pre-release code planned to ship as 27.01.1, as shipped and with one setting,ingest.sort_keys. TDengine TSDB-OSS 3.4.3.3, released 2026-10-18, with the database parameters from TDengine's own TSBS comparison scripts. - TSBS IoT, 24 hours at a 10-second interval, the same seeded data in both. TDengine prices per tag ("a unique time-series signal, typically Asset/Device + Measurement Name"); a TSBS truck has 10, so 1,000 and 10,000 trucks are TDengine's 10,000-tag and 100,000-tag price points.
- Both native on one Apple M3 Max (14 cores, 36 GB), one engine at a time. Medians of three or more runs. Every query instance returned the same number of rows on both engines.
Ingest
Time to load the full dataset with each engine's TSBS loader and 12 workers, every Arc write acknowledged durably: Arc answers a write only after it is synced to disk. TDengine's tested configuration answers before its WAL sync, which runs every 3 seconds; at its default WAL level it does not sync at all.
| Scale | Arc, sort keys | Arc, as shipped | TDengine | Arc, sort keys, queryable after |
|---|---|---|---|---|
| 10,000 tags (1,000 trucks, 15.6M rows) | 2.77 s (2.73–2.79) Arc 2.5x faster | 2.88 s (2.75–2.92) | 6.92 s (6.37–6.99) | 4.91 s (4.88–5.89) |
| 100,000 tags (10,000 trucks, 155.6M rows) | 24.4 s (24.3–24.9) Arc 7% faster | 25.9 s (25.8–26.0) | 26.1 s (25.5–26.2) | 27.5 s (27.1–27.6) |
Medians, range across runs in parentheses. The WAL is off in Arc's shipped config and was turned on for every run. Durable mode (wal.ack_mode = "durable") is planned for 27.01.1. Queued mode, the default, answers once a write is queued for the WAL: faster on the small load (1.5 s) and variable on the large one (21.8 to 45.6 s), so it is not the comparison here. On macOS Arc's fdatasync mode issues F_FULLFSYNC, a full drive cache flush, on every durable batch.
Storage
Bytes on disk after loading. Arc after its automatic compaction; TDengine after FLUSH DATABASE, data files only, since TDengine OSS refuses COMPACT DATABASE ("Operation not supported in community edition"). Neither figure includes the WAL: at 100,000 tags Arc's was 0.1 GB, TDengine's 9.6 GB, retained for 3,600 s by default.
| Scale | Arc, sort keys | Arc, as shipped | TDengine | Arc vs TDengine |
|---|---|---|---|---|
| 10,000 tags | 126 MB | 162 MB | 209 MB | 40% smaller (23% as shipped) |
| 100,000 tags | 1.27 GB | 1.78 GB | 2.38 GB | 47% smaller (25% as shipped) |
Sorting each truck's rows together puts similar values next to each other, so Parquet compresses them better.
Queries
Nine TSBS IoT query types, 20 instances each, warm median latency in milliseconds at 100,000 tags. As shipped, Arc sorts each measurement by time. One setting, ingest.sort_keys, sorts it by fleet and truck first, the layout TDengine gets from a table per device. Arc wins every aggregation over history and the 10-minute window, and the gap grows with scale. TDengine wins the latest value per truck, which its design is built for.
| Query | Arc, sort keys | Arc, as shipped | TDengine | Faster |
|---|---|---|---|---|
| Aggregations over hours of history | ||||
| Average vs projected fuel consumption per fleet | 87.2 | 83.3 | 544.7 | Arc 6.3x |
| Daily truck activity per fleet and model | 195.7 | 306.4 | 819.6 | Arc 4.2x |
| Trucks with long daily sessions (24 h) | 63.5 | 159.8 | 259.6 | Arc 4.1x |
| Trucks with long driving sessions (4 h) | 19.5 | 35.2 | 64.5 | Arc 3.3x |
| Latest value per truck | ||||
| Last location per truck | 45.4 | 120.7 | 13.9 | TDengine 3.3x |
| Trucks with high load (latest reading) | 75.4 | 176.5 | 10.9 | TDengine 6.9x |
| Trucks with low fuel (latest reading) | 27.1 | 53.4 | 15.2 | TDengine 1.8x |
| Per-truck aggregates | ||||
| Average load per truck model | 147.4 | 185.2 | 36.8 | TDengine 4.0x |
| Stationary trucks (first aligned 10-minute window) | 13.3 | 13.9 | 19.8 | Arc 1.5x |
"Faster" compares Arc with sort keys against TDengine, with the as-shipped result added where it differs. TDengine's figure is the faster of its REST and native clients, except daily activity, where only REST is shown: the native runner bucketed days in the local time zone.
At 10,000 tags
Every query finished in under 40 ms on both engines, so the differences are a few milliseconds. Arc's lead on aggregations over history appears and widens as the fleet grows.
| Query | Arc, sort keys | Arc, as shipped | TDengine | Faster |
|---|---|---|---|---|
| Aggregations over hours of history | ||||
| Average vs projected fuel consumption per fleet | 11.4 | 10.9 | 37.0 | Arc 3.3x |
| Daily truck activity per fleet and model | 25.6 | 28.9 | 31.1 | Arc 1.2x |
| Trucks with long daily sessions (24 h) | 14.7 | 21.6 | 20.3 | Arc 1.4x |
| Trucks with long driving sessions (4 h) | 7.9 | 9.1 | 7.4 | About even |
| Latest value per truck | ||||
| Last location per truck | 15.6 | 18.9 | 7.0 | TDengine 2.2x |
| Trucks with high load (latest reading) | 15.9 | 23.5 | 4.5 | TDengine 3.5x |
| Trucks with low fuel (latest reading) | 8.4 | 9.8 | 5.3 | TDengine 1.6x |
| Per-truck aggregates | ||||
| Average load per truck model | 19.9 | 21.3 | 3.1 | TDengine 6.3x |
| Stationary trucks (first aligned 10-minute window) | 5.3 | 5.5 | 4.5 | TDengine 1.2x |
Where the Designs Differ
Storage format
Files you own vs. a format you back up
Arc writes standard Parquet, partitioned by database, measurement and hour, on local disk, S3 or Azure. Spark, Trino or any Parquet reader can query the files without Arc, and on the local backend Arc can register them as Apache Iceberg tables. TDengine keeps data in its own format; its open-source taosdump can back it up to Parquet, and continuous export through taosX is Enterprise.
Data model
Columns across the fleet vs. one table per device
TDengine creates a table per device and keeps per-block sums, minimums and maximums, which makes the latest value of a device, or its average, cheap to find. Arc stores each measurement as columns across all devices, sorted by time or by the columns you choose, which makes scanning and aggregating hours of fleet history cheap.
What the free edition includes
Different lines between OSS and Enterprise
Arc OSS compacts automatically, runs on object storage, keeps Iceberg tables, subscribes to MQTT and ships edge sync. TDengine OSS includes three-replica clustering, which Arc reserves for Enterprise, while compaction, tiered and object storage, replication and its industrial connectors are TDengine Enterprise.
Pricing model
Per core, never per tag
TDengine All-in-One is priced per tag, so the bill grows with every sensor signal you add; its database alone, TSDB-Enterprise, is priced per core. Arc Enterprise is priced per core and machine and does not count tags, series or rows. Both have free AGPL-3.0 editions, and this benchmark compared those.
Features by Edition
Arc 26.09.x and planned 27.01.1; TDengine 3.4.x. TDengine facts are from its documentation and feature comparison page, read 2026-10-28.
| Capability | Arc | TDengine |
|---|---|---|
| Open-source edition | AGPL-3.0 | AGPL-3.0 |
| Commercial pricing unit | Per core and machine (Enterprise); never per tag | Per tag (All-in-One) or per core (TSDB-Enterprise) |
| Storage format | Open Parquet files, readable without Arc | Own format; the open-source taosdump can back up to Parquet (3.4.2.0+), zero-code Parquet export via taosX is Enterprise |
| Primary storage on S3-compatible object storage | OSS (S3, Azure Blob, local) | Enterprise: older data migrated to object storage (since 3.3.0.0) |
| Apache Iceberg tables | OSS, since 26.09.1 (local storage backend) | Not documented |
| Compaction | OSS, automatic (hourly and daily) | Enterprise: COMPACT DATABASE is refused in the community edition |
| Sort order per measurement | OSS: ingest.sort_keys, kept through compaction | Fixed: one table per device, ordered by time |
| Hot/cold tiering | Enterprise (Tier II and up) | Enterprise (multi-tier storage) |
| Clustering and HA | Enterprise (Tier II and up) | OSS (three-replica Raft); two replicas + arbitrator is Enterprise |
| Edge-to-cloud sync | OSS manual sync and signed air-gap bundles (26.09.1+); scheduled sync planned for 27.01.1, licensed | Enterprise (taosX) |
| MQTT ingestion | OSS, native subscriber (26.02.1+) | Enterprise (taosX zero-code connector) |
| OPC UA ingestion | Via Telegraf (OSS) | Enterprise (taosX connector) |
| InfluxDB line protocol | OSS | OSS (schemaless write) |
| SQL | PostgreSQL-compatible: window functions, CTEs, joins | Based on standard SQL with time-series extensions; OVER() since 3.4.2.0, joins without a timestamp condition since 3.4.3.0 |
| Data model | Measurements with tag and field columns | One table per device, grouped by supertables |
| Acknowledged write is on disk | wal.ack_mode = durable (planned for 27.01.1) | WAL_LEVEL 2 fsyncs every WAL_FSYNC_PERIOD (3 s default); level 1, the default, does not fsync |
Pricing
List prices per year, self-hosted, as published on 2026-10-28. Both databases also have a free AGPL-3.0 edition.
Arc Enterprise
Priced per core and machine. No tag, series or row limits.
- Tier I, $5,000: up to 8 cores, 1 machine
- Tier II, $15,000: up to 32 cores, up to 5 machines; adds clustering and tiered storage
- Tier III, $40,000: up to 128 cores, production + staging
- Unlimited, custom: unlimited cores, unlimited machines
TDengine
All-in-One (TSDB + IDMP) priced per tag; TSDB-Enterprise priced per core.
- All-in-One, up to 5,000 tags: free with registration, renewed yearly; direct third-party queries to the bundled TSDB need a TSDB-Enterprise license
- All-in-One, 10,000 tags: $15,500
- All-in-One, 100,000 tags: $46,000
- All-in-One, 500,000 tags: $110,000; high availability adds 30%
- TSDB-Enterprise: $5,000 for 2 cores up to $80,000 for 32 cores
Frequently Asked Questions
Is Arc faster than TDengine?
On aggregations over hours of history, yes. On TSBS IoT at 100,000 tags, Arc answered all four 1.6x to 6.5x faster as shipped, and 3.3x to 6.3x faster with sort keys on fleet and truck, and the 10-minute stationary-trucks query 1.5x faster. TDengine answered the latest-value-per-truck lookups (1.8x to 6.9x against sort keys) and the average load per model (4.0x) faster, which its one-table-per-device layout is built for. With durable acknowledgement and sort keys, Arc ingested 155.6M rows in 24.4 s against TDengine's 26.1 s, and 2.5x faster at 10,000 tags. Both engines returned the same number of rows for every query.
How do Arc and TDengine pricing compare?
Both have a free AGPL-3.0 edition. As of 2026-10-28, TDengine prices its All-in-One edition per tag: $15,500 a year at 10,000 tags and $46,000 at 100,000 tags, plus 30% for high availability; its standalone TSDB-Enterprise is priced per core, from $5,000 a year for 2 cores to $80,000 for 32. Arc Enterprise is priced per core and machine and never counts tags, series or rows: $5,000 a year for up to 8 cores on 1 machine, $15,000 for up to 32 cores on up to 5 machines.
Can I read Arc or TDengine data without the database?
Arc stores data as standard Parquet files on local disk, S3 or Azure, so Spark, Trino or any Parquet reader can query them directly; on the local backend Arc can also register them as Apache Iceberg tables. TDengine stores data in its own format; its open-source taosdump can back data up to Parquet files, and continuous export through taosX is an Enterprise feature.
What is open source in each?
Arc OSS includes Parquet on object storage, automatic compaction, configurable sort order, Iceberg tables, native MQTT ingestion and edge sync; clustering, tiering and RBAC are Arc Enterprise. TDengine OSS includes three-replica clustering; tiered and object storage, compaction, edge-cloud replication and the MQTT, OPC UA and PI connectors are TDengine Enterprise.
How was the benchmark run?
TSBS IoT, the same seeded dataset loaded into both engines, three or more runs each on one machine with the other engine stopped. TDengine used the database parameters from its own TSBS comparison scripts. Arc was built from main at 0080aa31 (pre-release 27.01.1) and tested as shipped and with one setting, ingest.sort_keys. The harness, configs and every raw result are public on GitHub.
Sources (read 2026-10-28)
- TDengine All-in-One pricing (per tag)
- TDengine TSDB-Enterprise pricing (per core)
- TDengine free tier terms
- TDengine OSS vs Enterprise feature comparison
- TDengine multi-tier storage (Enterprise)
- TDengine taosdump (Parquet backup format)
- TDengine data model: one table per device
- TDengine database parameters (WAL, cache)
- TDengine SQL reference
- TDengine license (AGPL-3.0)
- TDengine TSBS fork and comparison scripts
- Benchmark harness and raw results
- Arc WAL and acknowledgement modes
- Arc sort keys
Ready to handle billion-record workloads?
Deploy Arc in minutes. Own your data in open files on your storage. Use for analytics, observability, AI, IoT, or data warehousing.