Dippr splits into a control plane, which holds who you are and what you may do, and a data plane, which holds your compute and your rows. This page pulls together what a reviewer needs from across the docs: where data lives, who can see what, how secrets are stored, how agents and apps get access, how sign-in works, and what’s recorded.

Where your data lives

The control plane coordinates; it never stores a readable integration credential and never sees a query result pass through it. Your query engines, data apps and workspace databases all run inside a data plane, which connects outbound to the control plane, never the other way around. Every tenant starts on a shared plane that Dippr operates; if your data has to stay inside your own cloud account, you can register your own plane instead, connected over an outbound-only link. Your query results, the content your data apps generate, the rows an MCP tool call returns, and the rows in your workspace databases never cross into the control plane. The console reads result data straight from your data plane. The control plane does receive metadata about your data and the text of your queries; What leaves your data plane lists exactly what. See Data planes overview and How Dippr fits together. An integration’s credentials are sealed to the plane it’s registered on, so a query engine can only mount catalogs from integrations on its own plane, and a data app pushed to one plane’s registry can only be installed on that same plane.

What leaves your data plane

What leaves your data plane is everything a data plane sends to Dippr’s control plane, or to a third party, while it runs. This section lists every path, per component, with how long Dippr keeps what it receives, so you can review it against your own requirements. It applies to a shared plane and to your own plane alike.

What never passes through the control plane

On your own data plane, these are stored in your cloud account and never pass through Dippr’s control plane. They still reach the people, apps and clients you give access to, and an agent can send what it reads to a model provider, as Agents describes.
  • query results, and the rows an MCP tool call returns;
  • the content your data apps generate;
  • the rows and files of your workspace databases;
  • agent conversations, routine instructions and the reports routines write;
  • the contents of the Git repositories on your plane;
  • on your own plane, its private key.
Metadata about your data and the text of your queries do leave the plane. A query’s text can include values written into it, such as WHERE email = 'ana@example.com', so treat query text as data.

What crosses to Dippr

The times in this table are when data expires. Expired data is removed in the background, so it can stay a while longer; engine metrics are removed in batches, once every sample in a batch has expired.

What reaches third parties

Embedding provider

Search by meaning uses an embedding provider, a service that turns text into numbers so that similar phrases find each other. Dippr configures one provider per region: in the US region, it’s OpenRouter (openrouter.ai). The provider receives:
  • the searchable text of each catalog object: its names, type, comment and a table’s column names;
  • the shape of each query, with every string and number value replaced by ? and comments removed (text in a comment nested inside another comment can remain), plus the names of the tables it touches;
  • the names and descriptions of your integrations, semantic models, metrics, verified questions and business terms, including their synonyms;
  • each query you save: its name and its full SQL as written, values and comments included;
  • the words you type into a search.
It doesn’t receive query results. Names, comments and the words you type are sent as written, so a value copied into a comment or a search reaches the provider too. With no provider configured, search matches words only and nothing is sent. A per-tenant setting is coming that lets you use your own provider, or turn embedding off.

Agents

An agent reads data you allow it to read, with the same SQL access rules as you, and sends what it reads to a model provider. The built-in routine runner uses the model provider configured on the data plane it runs on. On your own plane, that model endpoint and its key are yours: you set both when you install the plane, and the key stays in your cluster. On a shared plane in the US region, it’s OpenRouter (openrouter.ai). An agent you or your team publish can also contact the external hosts its author declared, once you approve them at install, and what it sends there depends on that agent’s code. See Agent authoring.

Everything else

  • Images. A shared plane downloads Dippr’s software images from Dippr’s registry. Your own plane downloads them from the registry you set at install, usually your mirror of the release images. A few components use open-source images that are downloaded from their public registries, such as Docker Hub, unless you set each of them to your mirror too. A download carries the image name and, where one is needed, a download credential, nothing else.
  • dip telemetry. dip on your computer, not your plane, sends anonymous usage and failure events to Microsoft Azure Application Insights. No free text, paths, hostnames or names are sent, apart from a test label you set yourself. See CLI telemetry for every field and how to turn it off.
  • Support bundles. dip plane support-bundle builds a file on your computer and removes the secrets it can recognize. It says so when it couldn’t read your plane’s secrets, and short values may not be replaced everywhere, so read the file before you send it. Nothing leaves until you send that file to support yourself.
  • Your own infrastructure. Your plane also connects to systems you choose and run: your data sources and any SSH bastion in front of them, your object storage bucket, your DNS, and your cloud’s identity service when the plane signs in with workload identity. Those connections carry what each system needs, such as your queries to a source, and they belong to you, not to Dippr.

Compliance

Altimate, the company behind Dippr, is SOC 2 compliant.

Who can see what

Every tenant starts with six built-in roles, each inheriting everything the role below it can do: platform_admin isn’t one of these; it’s a flag a platform operator holds for supporting the whole platform, giving the same bypass as account_admin/data_admin inside any tenant they belong to. Switching to act as a single role (available to anyone holding more than one, including platform admins) only narrows what you can see; it can never grant something you don’t already hold. Beyond the console-level roles above, your query engine enforces data-level controls directly: See Roles and permissions and the full roles and permissions matrix for every privilege each role holds.

Secrets

Every secret field on an integration, a password, a key or a token, is sealed to the public key of the data plane you register it on, before it’s ever written to storage. Only that plane holds the matching private key; nobody else, including the control plane, can open it.
  • Reading an integration back never shows a secret’s value; the console always renders it hidden.
  • There’s no API or console action that retrieves a stored secret. If you’ve lost track of a value, you get it again from where it originated and re-enter it.
  • Leaving a secret field blank while editing keeps the stored value unchanged; a dedicated Remove action is the only way to clear one.
  • Moving an integration to a different data plane requires re-entering every secret, since a value sealed to one plane’s key can’t be transferred to another’s.
  • One kind, an SSH tunnel, holds a key pair Dippr generates for you; you never see or supply its private half. Rotate key invalidates the current pair and mints a new one immediately.
See Test connection and secrets for the full picture. A service user’s API key (alt_…) is shown to you once, at minting, and never again; losing it means revoking it and minting a replacement. You choose which capabilities a key carries before it’s minted, and a key’s actual reach is always its capabilities intersected with its service user’s roles, both have to allow a call. A key revoked from Settings → Service users is refused within a few seconds on the data plane; the console checks on every request. See Service users and API keys.

AI agents and apps

An agent connecting through MCP, Claude, Codex, Cursor, or dip itself, requests a set of named scopes, never roles. A scope is a ceiling on what a client may ever do, never a grant of new access: what a connection can actually do is its scope intersected with your own roles and grants, intersected again with the specific endpoint it authorized against. Every tool call runs as the connecting identity, so two connections holding the same scope can still see different data if the identity behind them differs. Approving a connection shows every scope it’s requesting before you consent, and scopes don’t change after you approve, even if your tenant later enables a capability the client would now like to use. See Scopes and consent. Removing an agent’s connection (for example claude mcp remove, or dip mcp uninstall) stops it being used going forward; even without that, its access ends on its own once its offline_access grant runs out, at most 30 days after approval. A revoked service-user key is refused within a few seconds on the data plane; the console checks on every request. Members can install their own static apps when their role allows Manage own apps. App administrators can also install other authors’ apps and apps that request write access. Before it runs, you review one row per capability it declares: read or write, the exact table scope, and the reason its author gave for needing it. You must approve every declared capability for the app to run. Every user who opens the app still only sees what their own grants allow; consent sets a ceiling and grants no new data access. App code is trusted and can retain rows it has received, so install code you trust. Uninstalling revokes the app’s OAuth client and deletes its consent grants. See Install an app.

Sign-in and sessions

Every query engine authenticates over OAuth2 and only OAuth2. A person’s sign-in renews on its own for as long as the session is used, so neither a long query nor a long time spent paging through results is bounded by a single token’s lifetime. A machine caller with no browser exchanges a service user’s API key for a token bound to one engine instead; that token is a fixed window rather than something the engine renews, and it’s never re-issued a refresh token, so a long-running script has to re-exchange the key rather than assume the credential renews itself. You revoke a member’s engine access the same way you’d revoke any of their access, through your tenant’s member and role management, not per engine. Revoking a service user’s API key from Settings → Service users stops it authenticating immediately; a client-credentials token it already holds still runs out on its own fixed schedule. See Engine sign-in and OAuth.

What is recorded

Two separate trails exist today. Actions taken from the platform admin console, such as creating or suspending a tenant, changing its plan, adding or removing a member, and toggling a feature flag, are written to an audit log; reads aren’t recorded this way, only the actions that change something. Deleting a tenant emits two audit records on a best-effort basis, one when deletion starts and another when every step has finished. A lost response after the deletion commits, or an audit event outage, can leave either record missing. The tenant’s status and deletion timestamp are the authoritative record of deletion; ask your platform operator to confirm them. Separately, each query engine keeps its own lifecycle history (what it went through: created, power changes, catalog updates), visible to anyone who can already read that engine, not only to admins, since it’s the same information as the engine itself. A tenant’s own audit log, distinct from an engine’s lifecycle history, is admin-only by default: only data_admin, account_admin and platform admins can see it. See Roles and permissions matrix. Registering, editing, deleting or testing an integration doesn’t currently produce an entry in either trail naming who did it. This is a known, tracked gap rather than an oversight: it doesn’t change what’s authorized, every one of those actions is still gated by role exactly as described above, it only means the record of who touched a credential isn’t reconstructable yet. See Test connection and secrets.

When a tenant is deleted

Deleting a tenant removes its access within minutes and then tears down everything it owns, on every data plane it used: installed apps and their images, query engines, workspace databases and their files, pipelines, integrations and data plane connections, roles and access rules, the search index, query history, the semantic layer and engine usage metrics. The tenant shows Deleting until every part reports nothing left; a part that is running is never skipped to make it finish. A part your deployment has turned off can’t remove anything, so it holds the deletion at Deleting until it is turned back on or your operator records that it never ran in your deployment. A part that ran before being turned off may still hold your tenant’s data; ask your platform operator to restore it so deletion can finish. Kept: the platform audit log, including every record about this tenant; the record of how the tenant was created; and the tenant’s own row, marked Deleted, with its teardown progress. The deletion also keeps its own bookkeeping: each part’s record of the deletion, the marker in each part that refuses any later write for the tenant, the record of each data plane removed from its last tenant, which data planes the tenant was ever connected to and when (so a later deletion can still reach a customer’s cluster it left), and the invitations it redeemed to join a data plane, until the inviting tenant is deleted or the plane is removed. The public hostnames of the tenant’s apps, made from its slug and each app’s name, also stay reserved, so an old address never reaches someone else’s app. Sign-in sessions opened in the tenant stay until they expire, any member’s offboarding still in progress stays until it finishes, and the notice that each of its API keys was revoked (holding a hash of the key, never the key) stays until a later revocation clears it. None of these hold query results, files or credentials, but they do hold identifiers: the tenant’s id, data plane ids, counts, error text, the names of the app repositories the deletion removed, and those hostnames. A tenant that left a customer’s data plane before your deployment was upgraded to record that may have leftovers there that the deletion doesn’t reach. Ask your platform operator to check that data plane for retained data.

Roles and permissions matrix

Every built-in role and every privilege it holds.

OAuth scopes reference

Every scope Dippr issues, what it lets a client do, and who can hold it.