Our editorial view: if sensor data must be joined with assets, sites and work orders, start with TimescaleDB (or plain PostgreSQL at modest volumes). For a dedicated, fully open source metrics and events store fed by Telegraf or line protocol, InfluxDB 3 Core, with Enterprise or cloud for high availability. For an Apache 2.0, SQL-first time-series engine, QuestDB. For long-term storage of Prometheus-style metrics, VictoriaMetrics. For industrial IoT with very many devices of the same type, look at TDengine (AGPL-3.0) and Apache IoTDB (Apache 2.0). Use ClickHouse when the job is analytics over very large event volumes, and Prometheus for infrastructure monitoring and alerting, not as a general sensor archive.
A time-series database stores values indexed by time: a reading, a timestamp and the identity of the thing measured. In facilities and IoT work that means BMS points such as AHU supply-air temperature, chiller kW and zone CO2, utility meters read every 1 to 60 seconds, and equipment signals that a CAFM or CMMS turns into maintenance work orders. This guide is for engineers and architects choosing where that data should live. For concepts and architecture, start with the time-series and IoT data hub.
Keep the three layers apart. Streaming (MQTT brokers, Kafka) moves messages from devices and gateways; the time-series database stores and queries them; analytics platforms (warehouses and lakehouses) combine history across systems. Several products below blur these lines with built-in brokers or processing engines, which can simplify small deployments but does not remove the need to decide where each responsibility lives.
For head-to-head detail see TimescaleDB vs InfluxDB and TimescaleDB vs PostgreSQL, and the product guides for TimescaleDB, InfluxDB and QuestDB.
Quick picks
PostgreSQL extension: hypertables, columnstore and continuous aggregates next to your relational tables.
MIT or Apache 2.0, line protocol, Telegraf ecosystem, SQL and InfluxQL.
SQL with SAMPLE BY, PostgreSQL wire protocol for queries, Parquet for older data.
Apache 2.0 single-node and cluster, Prometheus-compatible, accepts many ingestion protocols.
Data models built around many devices of the same type; check AGPL (TDengine) against Apache 2.0 (IoTDB).
How we chose
We considered time-series and time-series-capable databases with a public release in 2026 and official documentation in English: TimescaleDB, InfluxDB 3, QuestDB, VictoriaMetrics, TDengine, Apache IoTDB, ClickHouse and Prometheus, plus plain PostgreSQL as the baseline. Each was assessed against seven criteria, which are also the method we suggest you use:
| Criterion | What to check | Why it matters for IoT |
|---|---|---|
| Data model | Relational tables, tags and fields, metric labels, device trees or super tables | Decides how you model sites, assets and points, and how you join readings to business data |
| Query language | Standard SQL, a SQL dialect, or PromQL, MetricsQL or InfluxQL | SQL works with BI tools and analysts; metric query languages suit dashboards and alerts |
| Licence | The exact licence on the official licence page: permissive open source, copyleft, or source-available | Affects embedding, offering the database as a service, and which features you get for free |
| Self-hosting vs managed | Single node or cluster in the open edition; managed services and who runs them | High availability is often a paid feature; edge sites usually need self-hosting |
| Ingestion protocols | Line protocol, Prometheus remote write, PostgreSQL wire, MQTT, REST, native clients | Determines how gateways, Telegraf, Kafka consumers or MQTT bridges write data |
| Retention and downsampling | Per-table or per-database retention, automatic rollups, tiering to object storage | Raw 1-second data grows fast; summaries must outlive it for energy and maintenance reporting |
| Ecosystem | Grafana and BI connectors, client libraries, collectors, community and support | In our judgement, integration effort can outweigh licence costs |
In practice: shortlist on data model and query language, rule out on licence and deployment constraints, then run a proof of concept with your real point list, write rate, late-data pattern and the queries your dashboards and reports run. Our time-series performance guide explains how to keep such a test fair; sizing and schema patterns are in how to store IoT sensor data. The order below is not a ranking: SQL-based general options come first, then specialist and adjacent tools.
At a glance
| Database | Licence (checked on official page) | Open source or source-available | Data model | Query language | Ingestion | Lifecycle features | Managed option |
|---|---|---|---|---|---|---|---|
| TimescaleDB | Apache 2.0 core; Timescale License (TSL) for Community Edition features | Core open source; columnstore, continuous aggregates and retention policies are source-available (TSL) | Relational tables partitioned into time chunks (hypertables) | PostgreSQL SQL | PostgreSQL protocol (INSERT, COPY) | Chunk retention policies, continuous aggregates, columnstore | Tiger Cloud |
| InfluxDB 3 | Core: MIT or Apache 2.0; Enterprise: commercial | Core open source (single node); Enterprise proprietary | Tables of time, tags and fields | SQL, InfluxQL | Line protocol over HTTP; Telegraf | Per-database retention period; downsampling with processing engine plugins | Cloud Serverless, Cloud Dedicated, Amazon Timestream for InfluxDB |
| QuestDB | Apache 2.0; Enterprise: commercial | Open source; Enterprise adds HA, tiering and access control | Columnar tables with a designated timestamp, partitioned by time | SQL with time-series extensions (SAMPLE BY) | QuestDB Wire Protocol, InfluxDB line protocol, PostgreSQL wire protocol | Time partitions; Parquet conversion; automatic tiering in Enterprise | QuestDB Enterprise (cloud, on-premises or BYOC) |
| VictoriaMetrics | Apache 2.0; Enterprise: commercial | Single-node and cluster open source; Enterprise adds downsampling and retention filters | Metrics: name plus labels | MetricsQL (PromQL-like) | Prometheus scraping and remote write, InfluxDB line protocol, Graphite, OpenTSDB, OpenTelemetry, CSV | Global retention period (default 31 days); downsampling in Enterprise | VictoriaMetrics Cloud |
| TDengine | TSDB-OSS: AGPL-3.0; Enterprise: commercial | OSS open source (copyleft), includes clustering; Enterprise adds connectors, multi-tier storage and security features | One table per data collection point; supertables with tags | SQL with time-series extensions | SQL INSERT; schemaless InfluxDB line protocol and OpenTSDB telnet or JSON; MQTT, OPC and other no-code connectors in Enterprise | Per-database KEEP retention; last-row cache; stream processing; multi-tier storage and RSMA downsampling in Enterprise | TDengine Cloud (AWS, Azure, Google Cloud) |
| Apache IoTDB | Apache 2.0 | Open source (Apache Software Foundation) | Tree model (device paths) or table model | SQL dialects for each model | Native APIs, JDBC, REST, built-in MQTT service | Columnar TsFile storage with compression | None from the project |
| ClickHouse | Apache 2.0 | Open source | Columnar MergeTree tables | SQL | HTTP and native interfaces, many input formats | TTL rules delete or move data by age | ClickHouse Cloud |
| Prometheus | Apache 2.0 | Open source (CNCF project) | Metrics: name plus key/value labels | PromQL | Pull scraping over HTTP; push via a gateway; remote write out | Local retention defaults to 15 days; local storage not clustered | Many hosted Prometheus-compatible services |
| PostgreSQL | PostgreSQL License | Open source | Relational tables with range partitions | SQL | PostgreSQL protocol | Drop old partitions; materialized views; pg_partman | Offered by many cloud providers |
TimescaleDB
TimescaleDB, from Tiger Data, is a PostgreSQL extension for real-time analytics on time-series and event data. Hypertables partition tables by time into chunks automatically; the hypercore engine keeps recent data in a rowstore and converts older chunks to a compressed columnstore; continuous aggregates refresh rollups incrementally; and retention policies drop whole chunks. Because it is PostgreSQL, readings can be joined to asset registers and CMMS work orders in one query. The latest release on GitHub when checked was 2.31.0 (20 October 2026).
Licence: the repository's LICENSE file states that outside the tsl directory "source code in a given file is licensed under the Apache License Version 2.0, unless otherwise noted", and that within it source code "is licensed under the Timescale License, unless otherwise noted". Tiger Data's edition comparison places the columnstore, continuous aggregates, retention policies and the job scheduler in Community Edition (TSL). Tiger Data's licence page summarises the TSL as: "Roughly speaking, as long as you are not offering TimescaleDB as a hosted Database-as-a-Service, you can use all Community features for free." The TSL agreement is more detailed: it grants Internal Use, with conditions on who may reach the database's data definition and manipulation interfaces, and a separate Value Added Products or Services licence, and its section 2.2 prohibits "using any TSL Licensed Software to provide time-sharing services or database-as-a-service services". See the TimescaleDB guide and TimescaleDB vs PostgreSQL.
- In our view its most useful IoT features are the ones under the source-available TSL rather than an open source licence.
- You operate PostgreSQL as well: vacuum, upgrades, connection pooling.
- Other managed PostgreSQL services may offer only the Apache 2 edition, or none.
InfluxDB 3
InfluxDB 3 is written in Rust on Apache Arrow, DataFusion and Parquet. Data is organised in databases and tables whose columns are time, tags (identifiers such as site or sensor ID) and fields (values); it is written as line protocol and queried with SQL or InfluxQL. Flux, the language of InfluxDB 2.x, is not part of InfluxDB 3. An embedded Python processing engine runs plugins for transforms, downsampling and alerting, and the plugin library includes MQTT and Kafka subscribers. The vendor reports query response times under 10 ms for last-value queries. The latest release on GitHub when checked was v3.12.1 (dated 14 October 2026 in the release list).
Licence: the InfluxDB repository states: "The open source software we build is licensed under the permissive MIT or Apache 2 licenses at the user's choosing." (texts in LICENSE-MIT and LICENSE-APACHE). InfluxDB 3 Core is a single-node engine; InfluxData describes it as purpose-built for real-time monitoring and recent data. InfluxDB 3 Enterprise runs under a licence from InfluxData (its licence page lists Trial, At-Home and Commercial licences) and adds high availability, multi-node clustering, read replicas and long-range compaction. In Core, a database's retention period is set at creation and cannot be changed later. See the InfluxDB guide and TimescaleDB vs InfluxDB.
- High availability and long-range historical querying need the paid Enterprise edition.
- Joining with relational business data needs a second database or an export.
- Tag columns and Core retention periods cannot be changed after creation.
QuestDB
QuestDB describes itself as an open source, low-latency time-series database on open formats. Data lives in time-partitioned columns; older partitions can be converted to Apache Parquet. Queries use SQL with time-series extensions: SAMPLE BY groups rows into time buckets and requires a designated timestamp column. Clients can query over the PostgreSQL wire protocol with standard PostgreSQL libraries. For ingestion, QuestDB now recommends its own QuestDB Wire Protocol (QWP) for new clients and keeps InfluxDB line protocol as a compatibility path for Telegraf and existing pipelines. The latest release on GitHub when checked was 10.1.0 (22 October 2026).
-- Illustrative, not run here: from the QuestDB documentation; check it against the
-- documentation for your version before use.
SELECT ts, count() FROM trades SAMPLE BY 1h;Licence: the repository's LICENSE.txt is the Apache License 2.0. QuestDB Enterprise is commercial and adds replication with automatic failover, automatic tiering of cold partitions to object storage, and SSO, role-based access control and audit logs. See the QuestDB guide.
- High availability and automatic tiering are Enterprise features.
- SQL dialect has QuestDB-specific extensions, so queries are not fully portable.
- Better suited to append-heavy time series than to relational application data.
VictoriaMetrics
VictoriaMetrics is a time-series database and monitoring system. It implements MetricsQL, a PromQL-like query language, and accepts data through Prometheus scraping and remote write, InfluxDB line protocol, Graphite, OpenTSDB, OpenTelemetry, CSV and several agent formats, which lets it serve as a long-term store behind Prometheus. Retention is a global setting that defaults to one month (31 days). The latest release on GitHub when checked was v1.155.0 (26 October 2026).
Licence: the repository states that the single-node and cluster versions are under Apache License 2.0 (text in its LICENSE file). VictoriaMetrics Enterprise is commercial and adds downsampling, multiple retentions via retention filters, and long-term support releases. In our view it fits BMS data when readings are modelled as metrics with labels (site, building, point), and fits less well when you need SQL joins to business data.
- Downsampling and per-series retention are Enterprise features.
- MetricsQL, not SQL: BI tools and analysts need a different approach.
- Metric-and-label model is a poor fit for relational or event-detail data.
TDengine
TDengine TSDB is a time-series database that its documentation describes as designed for IoT platforms, industrial internet, power and IT operations. Data model: one table per data collection point. A supertable is the template for one device type: it defines the timestamp, the metric columns and the tags (static attributes such as location, model or group) and stores no data itself. Each device gets a subtable created from that template with its own tag values, and a query on the supertable covers all of its subtables, filtered by tag. Virtual tables combine columns from several source tables for devices whose sensors report at different rates.
Query language: standard SQL with time-series extensions: windows (INTERVAL, SESSION, STATE_WINDOW, EVENT_WINDOW, COUNT_WINDOW) with FILL, PARTITION BY tbname to compute each device separately, and functions such as time-weighted average; JDBC, ODBC, REST and client libraries connect BI tools and applications. Ingestion: SQL INSERT, which can create a device's subtable on first write, or schemaless writes in InfluxDB line protocol, OpenTSDB telnet or OpenTSDB JSON, which create supertables and subtables automatically. The zero-code data connectors for MQTT, OPC UA, OPC DA, Kafka, PI System and other sources run in taosX and are configured in taosExplorer; the documentation marks them, and taosX itself, as available in TDengine TSDB-Enterprise only, so with TSDB-OSS a bridge such as Telegraf or your own subscriber has to move data from an MQTT broker.
Retention, caching and processing: retention is set per database with KEEP (default 3,650 days, at least three times the file span DURATION); the architecture documentation says expired data files are deleted automatically. Multi-tier storage with several KEEP values and RSMA downsampled storage are Enterprise features; the community version applies the longest KEEP. CACHEMODEL (last_row, last_value or both) keeps the latest row or values of each subtable in memory so LAST_ROW and LAST serve current-status dashboards without reading history, at some cost on the write path. Built-in stream processing defines real-time transformations in SQL and writes results to target tables, and data subscription publishes topics through a Kafka-like API.
Deployment: clusters are deployed manually, with Docker or on Kubernetes; a highly available cluster needs three or more dnodes, three mnodes and databases with three replicas. TSDB-Enterprise can run at the edge, on premises or in public or private clouds, and TDengine Cloud delivers the Enterprise feature set as a managed service on AWS, Azure and Google Cloud. The latest release on GitHub when checked was 3.4.3.3 (release date in its notes: 18 October 2026); the documentation's release notes already list 3.4.3.6 (24 October 2026). Architecture, a plant-room schema and when not to use it are in the TDengine guide.
Licence: TDengine TSDB-OSS is under the GNU Affero General Public License v3.0 (AGPL-3.0); the vendor states that it includes clustering and is the code base of its paid offerings. AGPL-3.0 is a copyleft licence. Section 13 of the AGPL-3.0 text, "Remote Network Interaction", says: "Notwithstanding any other provision of this License, if you modify the Program, your modified version must prominently offer all users interacting with it remotely through a computer network (if your version supports such interaction) an opportunity to receive the Corresponding Source of your version". How that applies to a given deployment or product depends on the full licence text and the facts; this is not legal advice, so read the licence and take legal advice for your situation. TSDB-Enterprise adds, among other things, the zero-code connectors, fine-grained permissions, IP whitelisting, audit logs and encryption in transit and at rest. We did not confirm Enterprise or Cloud prices on a vendor pricing page, so none are quoted.
- AGPL-3.0 obligations apply to modified versions offered over a network.
- MQTT, OPC and other zero-code connectors, multi-tier storage and RSMA downsampling are Enterprise-only.
- Check the supported-platforms page for your operating system: its OSS list names Linux distributions, FreeBSD and macOS, and several entries are marked as Enterprise-supported.
- Its table-per-device model differs from both relational and tag-based designs, so plan the schema with care.
Apache IoTDB
Apache IoTDB is an Apache Software Foundation project for collecting, storing and analysing time-series data, aimed at industrial IoT. It stores data in TsFile, a columnar file format designed for time series. Version 2.0 offers two models: a tree model, where each data point is a path such as root.db.device01.metric that mirrors the physical plant, and a table model; the SQL dialect is chosen per session. It includes a built-in MQTT service, so devices can write directly without a separate broker, alongside native APIs for Java, Python, C++, Go and others, JDBC and REST. The latest release on GitHub when checked was 2.0.11 (11 September 2026).
Licence: the repository's LICENSE file is the Apache License 2.0. The built-in MQTT service is convenient for small deployments; at larger scale, in our view, a dedicated broker or Kafka between devices and the database still separates streaming from storage more cleanly.
- Two models and SQL dialects add a design decision that other products do not have.
- No managed service from the Apache project itself.
- Smaller English-language community and tooling ecosystem than PostgreSQL or InfluxDB (editorial).
ClickHouse
ClickHouse is an open source, column-oriented database for analytical reports, under Apache 2.0. Its MergeTree tables sort by a key you choose, partition by time and use TTL rules to delete or move data by age, and its documentation has a dedicated time-series guide. It is not a dedicated time-series database: there is no device model or last-value cache, primary keys do not enforce uniqueness, and updates work differently from an OLTP database. In our view it fits when the main job is aggregating very large numbers of readings across many sites, for example as the analytics layer fed from Kafka alongside an operational store.
See ClickHouse vs PostgreSQL for the model differences.
- Not a drop-in operational store: primary keys do not enforce uniqueness and frequent row updates are awkward.
- More design work (sort keys, partitions, TTL) than a purpose-built time-series database.
Prometheus
Prometheus, a Cloud Native Computing Foundation project under Apache 2.0, is a monitoring system: it scrapes metrics over HTTP (a pull model), stores them in a local time-series database, and evaluates PromQL rules for alerting. Its documentation is clear about the limits: local storage is not clustered or replicated, retention defaults to 15 days unless configured, and it is not a good choice where you need 100% accuracy such as per-request billing. The latest release on GitHub when checked was v3.15.1 (21 October 2026).
For BMS and IoT, Prometheus suits monitoring the gateways, brokers and servers in the pipeline. Our editorial view: for the sensor readings themselves, which you may need for years and for energy or compliance reports, use a database built for retention and SQL, or send Prometheus data by remote write to a long-term store such as VictoriaMetrics. See Prometheus vs Datadog.
- Local storage is single-node, not clustered or replicated.
- Pull model expects HTTP endpoints, which most field devices do not expose.
- Not designed for exact, complete records such as billing or metered energy.
Plain PostgreSQL
Before adopting a specialist database, check whether PostgreSQL alone is enough. Declarative range partitioning by time, a BRIN index on the timestamp, date_bin for bucketing, materialized views for rollups and the pg_partman extension for partition maintenance and retention can be enough at modest volumes (as an illustrative scale, hundreds to a few thousand points at minute intervals; where the limit lies depends on your hardware, query patterns and retention, so test with your own data), and keep readings next to assets and work orders. What it lacks is columnar compression and incrementally refreshed rollups; that is where TimescaleDB, an extension to the same database, comes in.
Licence: the PostgreSQL License, which the project describes as "a liberal Open Source license, similar to the BSD or MIT licenses"; pg_partman's LICENSE.txt states that it is released under the same licence. Examples that were run on PostgreSQL 18.6 are in TimescaleDB vs PostgreSQL; to set up a server, see PostgreSQL in Docker.
- No columnar compression in core; storage grows with raw data.
- Materialized views are recomputed in full on refresh.
- Partitions and retention need pg_partman or your own scripts.
How to choose
Our editorial view: start from the data and the people who will query it. If readings must be joined with assets, spaces and work orders, and analysts use SQL and BI tools, choose a SQL engine: plain PostgreSQL at modest volume, TimescaleDB as it grows, or QuestDB for a dedicated SQL time-series store. If the data is operational metrics viewed in Grafana and alerted on, a metrics stack fits: Prometheus for collection and alerting, with VictoriaMetrics or InfluxDB for longer retention. If you run large fleets of identical industrial devices, evaluate TDengine and Apache IoTDB, whose data models are built for that. If the question is cross-site analytics over years of history, add ClickHouse or a warehouse as the analytics layer rather than stretching the operational store.
Then apply the licence filter, using the licence texts linked in each entry. The permissive licences here (Apache 2.0, MIT, PostgreSQL License) grant broad rights with short conditions, such as keeping copyright and licence notices; AGPL-3.0 (TDengine) is a copyleft licence whose section 13 covers modified versions that users interact with over a network; the TSL that covers TimescaleDB's Community Edition features is source-available, and its section 2.2 prohibits using it to provide database-as-a-service services. Commercial editions are under each vendor's own terms. Not legal advice: this guide summarises and quotes licence texts as published on 27 October 2026; read the licences for the versions you use and take legal advice for your situation. Next, check which features are in the open edition: high availability is paid in InfluxDB 3 and QuestDB, and downsampling is paid in VictoriaMetrics. Finally, size retention: rows per day = points x (86,400 / sample interval in seconds), so, taking 2,000 points every 60 seconds as an illustrative assumption, that is 2.88 million rows a day; use your own point list and sampling intervals. Decide how long raw data must stay, which summaries replace it, and test with that volume before you commit.
Frequently asked questions
What is the best time-series database for IoT?
In our editorial view, it depends on the data model you need. For IoT data that must be joined with relational business data, TimescaleDB (or plain PostgreSQL at modest volume). For a dedicated metrics and events store, InfluxDB 3 or QuestDB. For industrial device fleets, TDengine or Apache IoTDB. Shortlist on data model, query language and licence, then test with your own data.
Which time-series databases are fully open source?
Under permissive licences: InfluxDB 3 Core (MIT or Apache 2.0), QuestDB, VictoriaMetrics, Apache IoTDB, ClickHouse and Prometheus (Apache 2.0), and PostgreSQL (PostgreSQL License). TDengine is open source under the copyleft AGPL-3.0. TimescaleDB is mixed: its core is Apache 2.0, but compression, continuous aggregates and retention policies are under the source-available Timescale License. Several projects also sell commercial editions with extra features. This is a summary of the published licence files, not legal advice.
Is Prometheus a time-series database?
It includes one, but it is a monitoring system first. Its local storage is not clustered or replicated, retention defaults to 15 days, and its documentation says it is not suited to cases that need 100% accuracy. Use it for infrastructure metrics and alerting, and a dedicated store for long-term sensor data.
Do I need a time-series database, or is PostgreSQL enough?
At modest volumes (as an illustrative scale, hundreds to a few thousand points at minute intervals), PostgreSQL with time partitioning, a BRIN index and materialized views can be enough. Consider a time-series database or the TimescaleDB extension when tests on your own data show that query times or storage growth no longer meet your needs, when storage cost needs compression, or when rollups must refresh incrementally. There is no universal row-count threshold; it depends on hardware, queries and retention.
Where do MQTT and Kafka fit?
They are the streaming layer, not the database. Devices and gateways publish to an MQTT broker or Kafka, and a consumer (Telegraf, a Kafka connector or your own service) writes to the time-series database. Some databases include an MQTT service or subscriber plugins, which is convenient for small setups.
Sources
- TimescaleDB GitHub repository
- Tiger Data: software licensing (Apache 2.0 and TSL)
- Tiger Data: compare TimescaleDB editions
- InfluxDB GitHub repository (licence)
- InfluxDB 3 Core documentation
- InfluxData pricing (Core vs Enterprise)
- QuestDB GitHub repository
- QuestDB: SAMPLE BY
- QuestDB: PostgreSQL wire protocol
- QuestDB: InfluxDB line protocol
- QuestDB Enterprise
- VictoriaMetrics GitHub repository
- VictoriaMetrics: single-node documentation
- VictoriaMetrics Enterprise
- TDengine GitHub repository
- TDengine licence (AGPL-3.0)
- TDengine TSDB documentation
- TDengine: introduction and offerings (OSS, Enterprise, Cloud)
- TDengine: basic concepts (supertables, subtables, tags)
- TDengine: database DDL (KEEP, CACHEMODEL)
- TDengine: architecture
- TDengine: schemaless ingestion
- TDengine: data connectors (Enterprise)
- TDengine: MQTT connector
- TDengine: taosX reference
- TDengine: read cache
- TDengine: time-series extensions
- TDengine: stream processing
- TDengine: RSMA downsampled storage
- TDengine: Kubernetes deployment
- TDengine: supported platforms
- TDengine: release notes
- TDengine releases on GitHub
- Apache IoTDB GitHub repository
- Apache IoTDB: modelling scheme (tree and table)
- Apache IoTDB: MQTT protocol
- ClickHouse GitHub repository
- ClickHouse: time-series use case guide
- ClickHouse: MergeTree table engine
- Prometheus GitHub repository
- Prometheus: overview
- Prometheus: storage
- PostgreSQL License
- pg_partman GitHub repository
- TimescaleDB repository: LICENSE file
- TimescaleDB repository: Timescale License agreement
- InfluxDB repository: LICENSE-MIT
- InfluxDB repository: LICENSE-APACHE
- InfluxDB 3 Enterprise: manage your license
- QuestDB repository: LICENSE.txt
- Apache License, Version 2.0 (apache.org)
- VictoriaMetrics repository: LICENSE
- GNU Affero General Public License v3.0 (gnu.org)
- Apache IoTDB repository: LICENSE
- pg_partman repository: LICENSE.txt
- InfluxDB releases on GitHub
Checked October 2026.
How we research these guides: our editorial method.