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.
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.
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.
diptelemetry.dipon 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-bundlebuilds 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.
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, ordip 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: onlydata_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.Related
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.