> Documentation index: https://docs.beetl.io/llms.txt

# What Beetl is

> A programmable data integration platform: connect business systems, transform data with SQL, then query it from chat or any MCP client.

Source: https://docs.beetl.io/getting-started/what-beetl-is/
Last updated: 2026-11-10

Beetl is a programmable data integration platform. It connects the business systems you already
run, transforms what comes out of them with SQL, and makes the validated result queryable,
chartable, and reachable from your own tools.

The short version: a lean data platform to enable data-driven teams with AI.

This page walks through five nouns in the order data moves through them, then the places
the output goes.

## The path data takes

```mermaid
flowchart TB
    accTitle: The path data takes through Beetl
    accDescr: A connection brings data into a Bronze dataset. A SQL pipeline transforms it into a Gold dataset. You can query the Gold dataset through chat or MCP, and read it in dashboards.
    connection["Connection<br/>(link to a system)"] --> bronze["Dataset<br/>(Bronze)"]
    bronze --> pipeline["Pipeline<br/>(SQL stages)"]
    pipeline --> gold["Dataset<br/>(Gold)"]
    gold --> result["Query result<br/>(saved with a URL)"]
    result --> chat["Chat"]
    result --> mcp["MCP"]
    gold --> dashboards["Dashboards"]
```

You configure each arrow once, and you can inspect every step afterwards.

## Connections bring data in

Data arrives in one of five ways:

* An **integration** is a connection from an installed Connect package, a short TypeScript program
  that reads a system's API on a schedule.
* A **webhook** gives you a token and an endpoint that your system posts JSON to.
* A **File Set** is a folder of files you upload. A file processor turns them into a dataset, and can
  read documents such as PDFs into records too.
* A **registered dataset** reads files already in your object store, in place without copying.
* An **external dataset** reads a live PostgreSQL table, in place without copying.

Integration code runs in an isolated sandbox inside Beetl and reaches your systems over HTTPS. Beetl runs nothing inside your network. See [Connect your data](https://docs.beetl.io/sources).

## Datasets are where data lands

A Dataset is a Delta Lake table in your tenant's object storage, either Beetl's hosted store or a
bucket you own. Every write is all-or-nothing, and Beetl maintains the tables automatically.

Each dataset has a tier: Bronze, Silver or Gold. Bronze is what arrived and Gold is what you would
hand to someone. The platform does not enforce that order; it is a naming convention your team
agrees on. There is no tier lineage DAG, and a Gold table can read from another Gold table.

Beetl checks schemas on the way in and never quietly coerces types. A sync rejects records that do
not match its integration's declared schema, and a pipeline run fails before writing if its output
does not match the destination. A file processor whose files no longer match its dataset fails and
keeps the dataset as it was. See [Datasets and tiers](https://docs.beetl.io/concepts/datasets-and-tiers).

## Pipelines transform

A Pipeline is a notebook. You pick source datasets, write SQL stages against them, preview any
stage on real rows, and optionally point the last stage at a destination dataset. Most exploration
starts with a pipeline that has no destination at all, and that is a perfectly good thing to build.

Every pipeline has two versions. Working is your editable draft, and Deployed is the version that
runs. Save writes the draft, and Deploy promotes it and starts a first run. Keeping them separate means an unfinished edit
can never run against production data.

## You query the result

The Query page is a multi-tab SQL editor over DataFusion, using the PostgreSQL dialect. It
autocompletes columns from the real schema, lets you cancel a long run, and charts what comes back.

Click any cell and Beetl shows the column's role, the SQL expression behind it, and the relations
it came from. When Beetl can build a deterministic path back to the contributing rows, it offers to
drill into them, and the drill-down is another addressable result.

Every result is saved with its own URL rather than living only on your screen, and it expires
after seven days. Read [Query results](https://docs.beetl.io/concepts/query-results) before you start relying on them.

## Where the output goes

The first is chat. The assistant sits in a sidebar on every page and also has a full-screen view.
It lists datasets, runs queries and builds pipelines through a fixed set of tools. Since August
2026 it can also edit the page you are looking at, on four surfaces.

The second is dashboards. A tenant can add Apache Superset dashboards, which read tenant data
read-only and open inside Beetl. You author them in Superset, and they are the only saved,
shareable charts in the product.

The third is PDF reports. A [report](https://docs.beetl.io/reports) binds a layout to SQL over your datasets and
issues PDF documents on demand or on a schedule, which you can view, download and tag.

The fourth is apps. An [app](https://docs.beetl.io/apps) is a ready-made application provided by Beetl that reads
datasets you choose and publishes its results back as datasets.

The fifth is MCP, which people tend to overlook. Beetl is an MCP server, authenticated with a
per-user API key scoped `read` or `write`. Claude, Cursor
or your own code get the same tools the in-product assistant uses.

## Automations run it on a clock

An Automation is a recurring investigation you describe in plain language. It runs on a cron
schedule with read-only queries and returns a Markdown report, along with every query it ran and
why. It can only observe: an Automation cannot propose or change anything.

## Where to go next

- [Quickstart](https://docs.beetl.io/getting-started/quickstart): Empty tenant to a query returning rows, one path.

- [Core concepts](https://docs.beetl.io/concepts): The core nouns, each in a paragraph.

- [The agent trust boundary](https://docs.beetl.io/concepts/agent-trust-boundary): What the assistant reads, what it writes, and where it is gated.

- [MCP and programmatic access](https://docs.beetl.io/mcp): Reaching the same tools from Claude, Cursor, or your own code.