duckdb.org No paid content found

What is DuckDB?

DuckDB is an open-source analytical SQL database designed to run in-process, meaning it operates inside your application rather than as a separate server you connect to over a network. It is built for OLAP (online analytical processing) workloads — the kind of heavy reads, aggregations and scans used in data analysis — and it uses a PostgreSQL-inspired SQL dialect that most analysts and developers can pick up quickly. It is MIT-licensed and governed by the independent DuckDB Foundation, so it is free to use and not controlled by a single vendor.

What makes it distinctive

• No server to manage. You install a library or CLI and query data directly, similar to how SQLite works but tuned for analytics instead of transactional workloads.
• Runs anywhere. The project describes deployment from edge devices up to servers with hundreds of cores, so the same engine can serve a laptop notebook or a large machine.
• Reads your existing files. It can read and write CSV, JSON, Parquet and Iceberg data, locally or in object storage, which means you often don't need to load data into a database first.
• Extensible. Extensions add functions and support for additional formats, so the core stays lean while coverage grows.
• Idiomatic clients. There are APIs for major languages including Python, R, Java, Node.js, Go, Rust, C and C++, plus a CLI and ODBC.

The wider stack

DuckDB is positioned as more than a single query engine. Alongside the database, the project describes a client-server protocol called Quack (where both client and server are full DuckDB instances, so computation can happen on either side), DuckLake (a SQL-based lakehouse format using object storage with a SQL catalog), and first-class Apache Iceberg support for reading and writing Iceberg tables.

When it fits, and when it doesn't

The practical trade-off is that in-process design buys simplicity and speed for single-user or embedded analytics, but it is not the same as a multi-user transactional server.

A concrete next step

If you have a large CSV or Parquet file and want to explore it without setting up infrastructure, install the CLI or the Python package and run a query directly against the file. The DuckDB site lists install commands for each client, and the documentation covers the SQL dialect and extension list if you need a specific format or function.

How do I install DuckDB for Python, Node.js, or the command line?

Install DuckDB through the package manager for your language or platform, then verify the version. The official site lists install commands for the command line, Python, Go, Java, Node.js, ODBC, and Rust, so use the one matching your environment.

Command line

The site shows a shell install script for the CLI:

curl https://install.duckdb.org | bash

It also lists a Windows CLI binary (duckdb_cli-windows-amd64.z…), so Windows users can download that instead of running the shell script. After installing, run duckdb --version to confirm the binary is on your PATH.

Python

pip install duckdb

This installs the Python client. In code, import duckdb and start a connection; the in-process model means you can query a Parquet or CSV file without running a separate server.

Node.js

npm install @duckdb/node-api

This is the Node.js client package named on the page. Check that your Node version meets the package requirements before installing.

Choosing between them

The main trade-off is not speed but workflow: the CLI is fastest to try, Python fits interactive analysis, and Node.js fits application code. All three talk to the same analytical engine, and the page notes native clients for other languages if your project uses them.

Next step

After installing, test with a small local file, for example a CSV or Parquet file, to confirm reads work in your environment. If you later need a shared or remote database, the page describes Quack, a client-server protocol where both client and server are DuckDB instances. For background and documentation, see DuckDB.

Can DuckDB read and write Parquet, CSV, JSON, and Iceberg files directly?

Yes. DuckDB is designed around reading and writing files directly, without a separate import step or a server to load data into first. Its own documentation lists Parquet, CSV, JSON, and Iceberg among the formats it can read and write, and it can do so either from local storage or from object storage. The same page also mentions Delta Lake, DuckLake, Avro, Excel, Arrow, Vortex, and Lance as supported formats, and geospatial data as an extension.

H3 What "directly" means in practice

• You point a SQL query at a file path or object-storage URL, and DuckDB treats it like a table. There is no loading phase to manage for CSV, JSON, or Parquet.
• Writing works the other way: query results can be exported straight to Parquet, CSV, or JSON files.
• Iceberg is handled with first-class support, so you can read and write Iceberg tables from DuckDB rather than converting them to another format first.

H3 Where the formats differ

H3 A concrete scenario

Suppose you receive a monthly CSV export, need to join it against a Parquet dataset, and publish results to a data lake. You could query the CSV and Parquet files together in one SQL statement, then write the output as Parquet or as an Iceberg table — all from the same session, using the CLI or a Python, R, Java, Node.js, Go, C, C++, or Rust client.

H3 How to decide

If you just need to inspect or transform a file, start with the command-line client. If the file lives in cloud object storage, check that your storage provider is among the integrations listed — Cloudflare, AWS, Azure, Google Cloud, and Hugging Face appear on the page. If you need shared, concurrent access with a catalog, Iceberg support is the relevant piece rather than plain Parquet.

Next step: install the client for your language and try a single SELECT * FROM 'yourfile.parquet' against a file you already have. If that works, the same pattern extends to the other formats. See DuckDB for the format list and client installs.

How does DuckDB differ from SQLite or PostgreSQL for analytical queries?

DuckDB is built for analytical (OLAP) work, while SQLite targets small transactional (OLTP) workloads and PostgreSQL is a general-purpose client-server database. That single design difference explains most of the practical trade-offs.

Where each one fits

• DuckDB runs in-process, like SQLite, but its engine is columnar and vectorized, so it scans and aggregates large tables quickly. Per its site, it is an "analytical SQL database that can run in-process," deployable "from edge devices to servers with hundreds of cores," with a PostgreSQL-inspired query language and native clients for Python, R, Java, Node.js, Go, Rust, C/C++ and the CLI.
• SQLite is also embedded and zero-configuration, which makes it excellent for application state, local caches and mobile storage. It is row-oriented, so wide scans over millions of rows for a GROUP BY tend to be slower than DuckDB.
• PostgreSQL is a server you connect to over a network, with mature concurrency, transactions, permissions and replication. It can handle analytics, but you usually add extensions or a separate warehouse for heavy columnar scans.

Formats and data location

DuckDB reads and writes CSV, JSON, Parquet, Iceberg, Delta Lake and DuckLake, locally or in object storage, and integrates with cloud storage such as AWS, Azure, Google Cloud, Cloudflare and Hugging Face. It can also query SQLite, MySQL and PostgreSQL databases. That means a common pattern: keep data as Parquet files in object storage, query them directly with DuckDB, and avoid loading a server at all.

A concrete scenario

An analyst has 40 GB of Parquet event logs in object storage and wants daily aggregates. With DuckDB, a Python or CLI session can query the files in place and return results in seconds, with no cluster to run. The same job in PostgreSQL means loading the data first and tuning the server; in SQLite it means importing into a single file that is awkward to share and slower to scan.

How to decide

DuckDB is not a replacement for a transactional server, and it does not offer PostgreSQL's multi-user concurrency controls. It complements both: use it as a local analytical engine next to the database that owns your writes.

Next step: install the CLI or Python package, point it at one Parquet or CSV file you already have, and run a GROUP BY to see the scan speed for yourself. See DuckDB for install commands and client options.

What is Quack and how does it enable client-server DuckDB access?

Quack is DuckDB's client-server protocol. It lets a client application talk to a remote DuckDB instance, so you are not limited to a database file sitting on the same machine as your code. The distinctive part is that both ends are full DuckDB instances: the server holds the database, and the client can also run computations locally against data it receives.

DuckDB

How it changes the access model

Normally, DuckDB runs in-process. Your Python, R, Java or CLI process loads the database directly, and queries execute inside that same process. That is simple and fast for local files, but awkward when several users or machines need the same data.

Quack adds a client-server option on top of that model:

• Remote access — a client connects to a server that owns the database.
• Client-side computation — the client is a full DuckDB instance, so it can process intermediate results rather than only displaying what the server returns.
• Same SQL surface — you keep DuckDB's PostgreSQL-inspired SQL and its format support rather than switching to a different query language.

Where it fits practically

Think of a small analytics team that keeps Parquet and CSV files on a shared server or in object storage. Without Quack, each analyst copies files locally or runs a separate process against the same files. With Quack, one server exposes the database, and analysts connect from notebooks or scripts. Because the client can compute locally, a notebook can pull a filtered result and then join it to a local dataframe without a second round trip.

This is also why Quack sits alongside DuckLake and Iceberg in the Duck stack. Quack handles the client-server connection; DuckLake and Iceberg handle lakehouse-style storage and catalogs. A team already using Parquet or Iceberg files can add Quack as the access layer rather than rebuilding its storage.

Trade-offs to weigh

Quack is not a drop-in replacement for a distributed warehouse. It is a way to keep DuckDB's simplicity while giving more than one process or person access to the same database.

Next step

If you already use DuckDB locally, the practical test is to take one shared dataset — say a Parquet folder on a server — and try reaching it from a second machine through Quack instead of copying it. If the client-side computation removes a data-transfer step you currently do by hand, Quack is worth adopting; if everyone works on one laptop, in-process DuckDB remains the simpler choice.

How does DuckLake work as a SQL-based lakehouse format on object storage?

DuckLake is the lakehouse format in the DuckDB stack. The core idea is that your table data lives in object storage while a SQL database acts as the catalog holding metadata — table definitions, snapshots, and file references. Clients query through DuckDB, which consults the catalog and then reads the underlying files from storage. The DuckDB page presents it as a lakehouse format built on SQL, with the catalog database providing scalability, simplicity and speed.

How the pieces fit

• Client — DuckDB (or a client speaking to a DuckDB server via Quack) issues SQL.
• Catalog — a SQL database stores metadata as ordinary tables rather than as files scattered in storage.
• Storage — object storage holds the actual data files; DuckDB reads and writes Parquet, CSV, JSON, Iceberg and related formats.

Why the SQL catalog matters

In file-based lakehouse designs, metadata is itself a set of files in object storage. Listing and reading many small metadata files is slow and creates consistency problems when several writers operate at once. Putting the catalog in a transactional SQL database moves that work to a system built for concurrent reads and writes, which usually means faster planning and simpler multi-writer coordination. Because the catalog is queried with SQL, you can inspect and join against it with the same skills you already use for data.

Practical scenario

A small analytics team keeps raw events in an object store and wants several analysts and a scheduled job writing at the same time. With DuckLake, they point DuckDB at a catalog database and a storage location, then query with normal SQL; the catalog handles who wrote what, while storage holds the bulk data cheaply.

Trade-offs to weigh

• You now run and back up a catalog database, so there is an extra component compared with a purely file-based setup.
• Object storage latency still applies to reading data files; the catalog speeds metadata access, not raw scans.
• Portability depends on other engines supporting the format, which matters if you do not want to be tied to DuckDB clients.

Next step

Run a small proof of concept: write one table to DuckLake, query it from DuckDB, then open a second client session and write concurrently. If both sessions see consistent results and planning stays fast as you add tables, the catalog approach is paying off for your workload. For related formats and clients, see DuckDB and its Iceberg support.