Installation To use the DuckDB Rust client, visit the Rust installation page.

The latest stable version of the DuckDB Rust client is 1.5.5.

The DuckDB Rust client, duckdb-rs, is an ergonomic wrapper over the DuckDB C API that exposes an interface modeled on rusqlite. It supports type-safe queries, bulk loading with the Appender, Apache Arrow interchange, user-defined functions, and building DuckDB extensions in Rust. This page focuses on installation. The other pages in this section cover connecting and each feature in detail.

Installation

The DuckDB Rust client is published on crates.io. The full API is documented on docs.rs. Add it to a project with cargo, enabling the bundled feature so that DuckDB is compiled from source and no system library is required:

cargo add duckdb --features bundled

The equivalent Cargo.toml entry pins the version. Starting with DuckDB v1.5.0 the crate version has the form 1.⟨major_minor_patch⟩.x. A tilde requirement receives patch releases without changing the bundled DuckDB version:

[dependencies]
duckdb = { version = "~1.10505.0", features = ["bundled"] }

The bundled feature is the simplest way to get started. Without it, the libduckdb-sys crate links against a system DuckDB library instead of compiling one, which is covered in Troubleshoot.

To track the latest bindings before they are released on crates.io, depend on the main branch or a specific commit from git. The bundled DuckDB version is whatever that commit vendors:

[dependencies]
# Latest development version
duckdb = { git = "https://github.com/duckdb/duckdb-rs", branch = "main", features = ["bundled"] }

# A specific commit
duckdb = { git = "https://github.com/duckdb/duckdb-rs", rev = "abc123def", features = ["bundled"] }

For the LTS release line that stays on DuckDB 1.4 Andium, use the v1.4-andium branch.

Tip The Rust client offers a large set of Cargo feature flags that turn on file-format readers, the Arrow and Polars integrations, connection pooling, and the function and extension interfaces. Enable only the features a project uses to keep build times and binary size down.

Basic API Usage

To use DuckDB, first initialize a Connection with Connection::open_in_memory() for an in-memory database, or Connection::open(path) for a database file. Queries are sent with execute() and execute_batch(), and results are read by preparing a statement and mapping each row to a Rust value with query_map():

use duckdb::{params, Connection, Result};

#[derive(Debug)]
struct Person {
    id: i32,
    name: String,
    data: Option<Vec<u8>>,
}

fn main() -> Result<()> {
    let conn = Connection::open_in_memory()?;

    conn.execute_batch(
        r"CREATE SEQUENCE seq;
          CREATE TABLE person (
              id   INTEGER PRIMARY KEY DEFAULT NEXTVAL('seq'),
              name TEXT NOT NULL,
              data BLOB
          );",
    )?;

    let me = Person {
        id: 0,
        name: "Steven".to_string(),
        data: None,
    };
    conn.execute(
        "INSERT INTO person (name, data) VALUES (?, ?)",
        params![me.name, me.data],
    )?;

    let mut stmt = conn.prepare("SELECT id, name, data FROM person")?;
    let person_iter = stmt.query_map([], |row| {
        Ok(Person {
            id: row.get(0)?,
            name: row.get(1)?,
            data: row.get(2)?,
        })
    })?;

    for person in person_iter {
        println!("Found person {:?}", person.unwrap());
    }
    Ok(())
}

This example is adapted from the crate's basic example. Run Queries covers sending queries and reading results in full.

Feature Flags

The crate is modular: most integrations are gated behind Cargo features that are off by default. Enable them in the dependency declaration, for example features = ["bundled", "vtab", "appender-arrow"]. The following is the complete set of the crate's Cargo features, grouped by purpose.

Building DuckDB

File Formats

Both imply bundled.

Bundled Extensions

Each statically links the matching bundled extension. All imply bundled-cmake, so they need a git checkout.

Table and Scalar Functions

Ecosystem Integrations

Umbrella Features

Deprecated Features

Further Reading

• Connect — opening in-memory and file-backed databases, Config options, connection pooling, and thread safety.
• Run Queries — execute(), prepared statements, parameter binding, and mapping rows to Rust types.
• Import Data — bulk loading with the Appender and reading directly from Parquet, CSV, and JSON files.
• Handle Results — Apache Arrow and Polars result interchange.
• Write User Defined Functions — user-defined scalar and table functions, and loadable extensions.
• Profile and Monitor — query profiling and interrupting long-running queries.
• Troubleshoot — linking, the ICU extension, and extension-versus-client build issues.
• Clients Overview — the other client APIs DuckDB provides alongside Rust.