Supercharge dbt. One project. All the sources.

Unlock multi-source models in dbt. Ingest data from Stripe’s API. Extract from MongoDB and load into Redshift. Join PostgreSQL and Snowflake in a single model. All your data in one place.

See the dbt workflow demo

Works with dbt-core and dbt Cloud. You connect through stock dbt-trino pointed at the Datattach endpoint — there's no custom adapter to install.

Multi-source models

Join across sources in a single model

With Datattach behind dbt, one model can read from several connected sources at once. A single SELECT that joins a Postgres table with a Snowflake table? No problem — save it as a view or materialize it as a table in your warehouse.

Join tables from different sources in one model
No pre-loading, syncing, or copies — unless you want to
Connector-agnostic — Treat all your sources like a single database

customer_360.sql — one model, two sources

-- models/marts/customer_360.sql
SELECT
    c.id,
    c.name,
    o.lifetime_value
FROM postgres.public.customers c
JOIN snowflake.analytics.order_rollup o
    ON o.customer_id = c.id

Extract & load

Move data between sources, in dbt

Materialize a model into a different source than it reads from. Extract from MySQL and land the result in Redshift as a table — a governed extract-and-load step expressed as a plain dbt model.

Read from one source, materialize into another
Just a dbt model with a target database
Incremental strategies supported
Every statement observed and audited

orders.sql — MySQL → Redshift

-- models/warehouse/orders.sql
{{ config(
    materialized='incremental',
    database='redshift',
    unique_key='id',
    incremental_strategy='delete+insert'
) }}

SELECT *
FROM mysql.shop.orders
{% if is_incremental() %}
WHERE updated_at > (SELECT MAX(updated_at) FROM {{ this }})
{% endif %}

SaaS ingestion

Ingest from SaaS APIs — as dbt models

Pull data straight from SaaS APIs — Stripe today, more on the way — with materialized='ingest'. Declare the source, and dbt run extracts the data and lands it as a table in a warehouse you own. No separate EL tool, no second scheduler — the dbt DAG is the pipeline.

Incremental by default — each run pulls only records newer than the landed table's cursor
Lands in a catalog you own — never a copy inside Datattach
Downstream models ref() the landed table in the same run
API credential registered once, encrypted — never in dbt config or logs

Explore SaaS ingestion →

stg_stripe_customers.sql — Stripe → your warehouse

-- models/ingest/stg_stripe_customers.sql
{{ config(cursor='created') }}

SELECT * FROM {{ source('stripe_prod', 'customers') }}

How it runs

Efficient runs. Native or federated.

Single-source models can run natively inside the source database — faster and cheaper. Anything that spans sources runs federated through Datattach. The decision is automatic and never changes the query output.

Your entire stack in one place

Every connected source becomes a catalog your dbt models can read from — and build into. SaaS data arrives through ingest models in the same project.

OLTP databases

Operational databases, queried live.

PostgreSQL

MySQL

SQL Server

Data warehouses

Analytical warehouses, side by side.

Snowflake

Amazon Redshift

Lakehouses

Open table formats on object storage.

Apache Iceberg

Databricks / Delta

SaaS APIs

Landed by ingest models on every dbt run.

Stripe more on the way

See all connectors →

Attach in minutes. Seriously.

Point your existing dbt project at Datattach without a rewrite — three steps, no custom adapter.

Provision a build credential

The Connect dbt page mints a token and generates copy-paste config for dbt-core and dbt Cloud.

Point dbt at Datattach

Drop the config into profiles.yml. Stock dbt-trino pointed at the endpoint — nothing else to install.

dbt run

Your existing models build — now federating across every connected source.

Most projects change only the connection

Just copy-paste the pre-generated config to update your profiles.yml file. That's it for most projects.

Ingesting SaaS API data? You'll also install the Datattach dbt package
Using incremental merge strategy? Install the Datattach dbt package and copy-paste a small macro
Want pointers for your multi-source project? We'll give you some tips on folder structure and configs so you can handle model configs across sources without thinking twice

profiles.yml — generated for you

my_project:
  target: dev
  outputs:
    dev:
      type: trino
      method: none        # auth via header token
      host: <proxy-host>  # from the Connect dbt page
      port: <proxy-port>
      http_scheme: https
      user: <dbt-build-principal>
      database: <catalog-name>  # a connected catalog
      schema: analytics
      threads: 4