Databricks Field Guide

Analysing and serving · Chapter 16

Delta Sharing, Databricks Clean Rooms and the Marketplace

Reviewed by TechFabric engineers. How we write this guide →

Delta Sharing, which Databricks' documentation now calls OpenSharing, lets another organisation read tables you govern in Unity Catalog without you sending a copy: you grant a share to a recipient, and they query your storage through short-lived credentials you can revoke. Databricks Clean Rooms is built on top of it for the opposite case, where two to ten parties need a joint result and none of them may see the others' rows, so the analysis runs as an approved notebook in an isolated environment and only output tables come back. Marketplace is the same plumbing pointed the other way, for acquiring somebody else's data as a catalog.

This chapter has the SQL for each, the defaults that changed in September and October 2026, and the places each mechanism fails. Facts are as of 22 October 2026.

The short version

If a partner needs to read your table, share it: they read the live version, you can revoke it in one statement, and every read lands in your audit log. If two companies need an answer from combined data and neither may see the other's rows, use a clean room, and treat approving its notebook as a security review, because the approval is the whole control. If you need third-party data, look in Marketplace before you build a pipeline. The mistake we'd watch for is using a share for a problem that needed a clean room.

Your rows

Only an agreed result

You want their data

yes

no, can federate

no, cannot

What may the other
party see?

Share a table
OpenSharing

Clean room
approved notebook

Marketplace listing
arrives as a catalog

Are they on
Databricks?

Databricks-to-Databricks
no credential to leak

Open sharing
with OIDC

Open sharing
bearer token file

Which mechanism fits: how much the other party may see decides it

How does Delta Sharing work? #

Three objects carry the model. A share is a read-only collection of tables, views, volumes and models in the provider's metastore. A recipient is the named party that may read it. A grant connects the two. The recipient never receives files; their client asks your metastore for the table, gets back short-lived pre-signed URLs to the Parquet files of the version they're entitled to, and reads them from your cloud storage. That's why a partner sees this morning's data without a pipeline on either side, and why revocation is immediate.

The name is in transition. The docs and the UI say OpenSharing, while the open protocol, the Python client (pip install delta-sharing), the Spark format name (deltaSharing) and the audit event names still say Delta Sharing. Search for both when you're debugging.

Recipient Mode we'd use What it can carry The catch
A workspace on a different metastore in your own account Databricks-to-Databricks Tables, streaming tables, managed Iceberg tables, views, materialized views, metric views, volumes, models, notebook files None worth naming; nothing to switch on
A partner on Databricks, any account, cloud or region Databricks-to-Databricks, by their sharing identifier The same full set Cross-region reads cost you egress
A partner off Databricks whose IdP you can trust Open sharing with OIDC federation Tabular data only Their IdP team has to configure a client
A partner off Databricks who can't federate Open sharing with a bearer token Tabular data only A long-lived secret in a file you mailed
Not sure yet OpenSharing by email (Beta) Whatever mode they pick No OIDC; an account admin enables it first

The asset list is from the OpenSharing overview (updated 12 October 2026). Open sharing doesn't carry notebooks, volumes, models or metric views, which surprises teams that built a share in their own account and then offered it to an outside partner.

The two modes, and what each one costs you #

Databricks-to-Databricks sharing carries the full asset set and has no credential to lose, because trust is anchored in the recipient's metastore identity. Open sharing reaches any client but carries tables only, and authenticates with either a token file or the partner's identity provider. In both, the partner reads your storage, so the cost lands with you as provider. Either mode can share a whole schema with ADD SCHEMA, which carries everything in it, including tables created after the grant. That convenience is also why we'd never share a schema anyone can write to: a table a colleague creates on a Tuesday afternoon becomes a shared table without a review having happened.

How do you share a table with another Databricks account? #

Ask the recipient to run SELECT current_metastore(); on their side. It returns their sharing identifier in the form aws:us-west-2:<uuid> (function reference). Then, as the provider, with CREATE SHARE and CREATE RECIPIENT on the metastore and SELECT on the tables:

-- Provider side. Names are examples; the syntax is current as of October 2026.
CREATE SHARE IF NOT EXISTS dealer_partner_share
  COMMENT 'Daily originations aggregates for dealer group partners';

-- History is the default for table shares on Runtime 16.2 and above; saying it keeps older clusters honest.
ALTER SHARE dealer_partner_share
  ADD TABLE originations_prd.gold.loan_application_daily
  AS partner.loan_application_daily
  WITH HISTORY;

CREATE RECIPIENT IF NOT EXISTS northwest_motors
  USING ID 'aws:us-east-1:19a84bee-54bc-43a2-87de-023d0ec16016'
  COMMENT 'Dealer group partner, contract DG-2031';

GRANT SELECT ON SHARE dealer_partner_share TO RECIPIENT northwest_motors;
SHOW GRANTS TO RECIPIENT northwest_motors;

The recipient mounts it as a catalog and grants it internally like any other:

-- Recipient side
CREATE CATALOG IF NOT EXISTS northwest_partner_data
  USING SHARE originations_provider.dealer_partner_share;

SELECT * FROM northwest_partner_data.partner.loan_application_daily VERSION AS OF 3;

Time travel and streaming reads need the table shared with history and the recipient on Runtime 12.2 LTS or above (reading shared data). If they'll read the change data feed with table_changes(), turn change data feed on before you add the table.

Two details from the create share page (updated 15 October 2026) cause most surprises. Whoever adds a table must keep SELECT on it, so a share owner who loses access to the source quietly breaks the share. And a shared schema should be one that only a pipeline writes to, for the reason above.

One share, many partners: partition by recipient property #

When every partner should see only their own rows, the share itself can filter. Give each recipient a property and reference it in the partition clause:

ALTER RECIPIENT northwest_motors SET PROPERTIES ('dealer_group' = 'NWM');

ALTER SHARE dealer_partner_share
  ADD TABLE originations_prd.gold.loan_application_by_group
  PARTITION (dealer_group = CURRENT_RECIPIENT().dealer_group)
  AS partner.my_applications;

The column has to be a partition column of the shared table, so this works where the table is laid out by the tenant key. For the general problem of tenants in one table, Multi-tenant reporting covers row filters and the identity question.

How do you share with someone who isn't on Databricks? #

Open sharing. With a bearer token, CREATE RECIPIENT partner_name; (no USING ID) produces an activation link, the recipient downloads a credential file once, and any Delta Sharing client reads with it:

# pip install delta-sharing   (the open-source client; reads tables only)
import delta_sharing

profile = "/secure/path/config.share"   # the credential file from the activation link
table_url = f"{profile}#dealer_partner_share.partner.loan_application_daily"

df = delta_sharing.load_as_pandas(table_url)
print(df.head())

That file is a bearer secret, valid for up to a year, and it's exactly as safe as the shared drive it ends up in. Rotation is a CLI call, databricks recipients rotate-token <recipient-name> <expiration-seconds>, and passing 0 expires the old token at once if you think it leaked (bearer-token recipients).

Where the partner has Entra ID, Okta or another OIDC provider, we'd use OIDC federation instead. You set a policy naming their issuer URL, the claim to match (for Entra ID, oid for a user, groups for a group, azp for an application) and the audiences; their IdP issues the JWT and Databricks exchanges it for a short-lived token. Power BI and Tableau use the user flow, and the Python and Spark clients use client credentials. No secret crosses between the companies.

A date to put in a calendar: Databricks is moving open-recipient token URLs to a recipient-specific format, and bearer tokens created before that change expire one year from creation or on 8 December 2026, whichever is later (what's coming, updated 21 October 2026). Any partner on a token from late 2025 needs a rotated file before December.

Who pays for a shared read? #

Within one cloud region there's no egress charge. Across regions or clouds, the recipient reads your bucket and the cloud bills you (managing egress). The documented ways down are a regional replica (a deep clone in the recipient's region, refreshed from the change data feed) or an egress-free object store such as Cloudflare R2 for the shared copy. Databricks also says networking charges for sharing are being extended, with some billed to recipients, so we'd write who pays egress into the data agreement before the first busy partner arrives.

What changed in September and October 2026 #

The September release notes moved a lot of sharing to GA:

  • Foreign Iceberg tables and foreign schemas and tables reached through Lakehouse Federation (11 September), and foreign Delta tables (15 September), can go into a share without an ingestion pipeline first.
  • Metric views can be shared (GA 24 September), in Databricks-to-Databricks mode only.
  • Table update triggers on shared objects (30 September), so a recipient's Lakeflow job can run when your table changes instead of on a guess at a schedule.
  • Invitations by email went to Beta (22 September).

How a foreign table reaches the recipient depends on its type and on who reads it (adding foreign tables). A Databricks recipient reads a foreign Delta table straight from the source files with cloud tokens, always with full history and no partition filter, so nothing is copied. For an open recipient the same table is materialised on your side and served through pre-signed URLs. Foreign schemas and tables reached through Lakehouse Federation are always queried and temporarily materialised on the provider's side, and foreign Iceberg tables are too for open recipients that don't use an Iceberg client, on your compute and storage. So for those paths the copy didn't disappear, and the recipient's reads trigger your spend. We'd use it to retire pipelines that only exist to feed a share, tag those shares, and watch provider-side cost for a full billing cycle before adding a second recipient.

Auditing a share #

Reads land in system.access.audit under two event names (OpenSharing audit logs). A deltaSharingQueriedTable event carries the table, version, recipient ID, record count and bytes scanned in the JSON response.result. A Databricks recipient reading a table shared with history doesn't produce that event; it asks for a short-lived storage credential, logged as generateTemporaryTableCredential with recipient_name and table_full_name in request_params. A query that only looks for the first event misses most Databricks-to-Databricks reads. This one counts both for the last 30 days:

SELECT date(event_time) AS day,
       action_name,
       coalesce(request_params['recipient_name'],
                get_json_object(response.result, '$.deltaSharingRecipientId')) AS recipient,
       coalesce(request_params['table_full_name'],
                get_json_object(response.result, '$.tableName'))               AS shared_table,
       COUNT(*)                                                                AS reads,
       SUM(CAST(get_json_object(response.result, '$.numRecords') AS BIGINT))   AS records_via_server
FROM system.access.audit
WHERE action_name IN ('deltaSharingQueriedTable', 'generateTemporaryTableCredential', 'generateTemporaryTableCredentials')
  AND event_time >= current_date() - INTERVAL 30 DAYS
GROUP BY ALL
ORDER BY reads DESC;

The docs spell the credential event both with and without a trailing "s", hence both in the filter, and say the field lists aren't exhaustive, so we'd check one raw event of each kind in your own audit table before building a dashboard on it. Credential events have no record counts, because the recipient reads your storage directly after receiving the credential. Run it after a revocation too; a recipient still appearing the day after means the revoke didn't land where you thought. REVOKE SELECT ON SHARE ... FROM RECIPIENT withdraws one share, and DROP RECIPIENT ends all of them at once, which is why we'd keep one recipient object per partner and never share one between two.

How do Databricks Clean Rooms work? #

A clean room is an isolated, Databricks-managed environment where each collaborator shares in tables, views, volumes or notebooks, sees the others' column names and types but not their rows, and runs only code everyone else has approved. Results come back as output tables. Requirements, from the Clean Rooms overview (updated 8 October 2026), are a workspace with Unity Catalog and serverless compute, and OpenSharing enabled on the metastore.

The rules that shape a design:

Rule What it means in practice
Up to ten collaborators, including the creator Fixed at creation; once created the room is locked and nobody new can join
The central room's cloud must match yours; the region can differ AWS regions include us-east-1, us-east-2, us-west-2, eu-west-1 and eu-central-1, among others
Name and network policy (Full or Restricted access) can't change Pick Restricted unless a notebook truly needs the internet
Each notebook has one designated runner Only the runner can run it, and only after approval
Every collaborator except the uploader must approve Any change to the code or the runner makes a new version and resets every review
Output tables are read-only and kept 30 days Each run writes a new schema; copy what you need to keep

Those come from the create, notebook and output table pages, updated 6 to 20 October 2026. In the UI, creation goes through Catalog Explorer, where you paste each collaborator's clean room sharing identifier (their global metastore ID, workspace ID and a contact email).

PublisherClean roomAdvertiserPublisherClean roomAdvertiserShare customers tableShare audience tableUpload notebook, runner =AdvertiserReview this versionApproveRun approved notebookOutput table, 30 days
The approval loop that makes a clean room a clean room

Inside a notebook, tables are referenced through the catalog names the room assigned at creation (creator and collaborator in a two-party room, so a table appears as creator.sales.customers), and outputs go to the schema the run hands you in parameters. This SQL notebook computes overlap and suppresses small groups:

-- Runs inside the clean room. :cr_output_catalog and :cr_output_schema are supplied per run.
CREATE TABLE identifier(:cr_output_catalog || '.' || :cr_output_schema || '.overlap_by_region') AS
SELECT a.region,
       COUNT(DISTINCT a.hashed_email) AS matched_customers
FROM creator.marketing.customers AS a
JOIN collaborator.publisher.audience AS b
  ON a.hashed_email = b.hashed_email
GROUP BY a.region
HAVING COUNT(DISTINCT a.hashed_email) >= 50;   -- no group small enough to point at a person

To publish one result every party can read, write to :cr_shared_output_schema instead. Shared output is fixed when the room is created and can't be switched on later, and every collaborator's account must have the same setting; on Enterprise accounts it's off by default until an account admin enables "Clean Room Shared Output" on the account console's Previews page, and creation fails while the settings differ (output table prerequisites). Shared output went GA on 13 October 2026, as did running compiled Java or Scala as a clean room task (October release notes). Running needs EXECUTE CLEAN ROOM TASK, and approving or rejecting needs MODIFY CLEAN ROOM.

The default that undoes the control #

Auto-approval exists, and one form of it is on by default: when another collaborator uploads a notebook and names you as its runner, it's auto-approved for you (notebook page). That's convenient for the party who receives the output and wrong for the party whose rows go in. You can also configure rules that auto-approve notebooks from "Anyone" or from one collaborator. We'd allow none in a room that holds personal data, and give the review a named owner and a written record of what was checked: which columns reach the output, the minimum group size, and whether the output could be joined back to a known person.

The privacy guarantee comes from code review, not from a mathematical bound. An aggregate over a small overlap can identify people while still looking like an aggregate, which is why the HAVING threshold above matters more than the room.

Packaged rooms and auditing #

Packaged clean rooms are the other type: a provider ships a fixed analysis and consumers bring data to it. Since 13 October 2026 you can create one in a single step with identity resolution providers such as Acxiom, Adstra, LiveRamp and The Trade Desk (packaged clean rooms). Auto-approval rules don't apply to packaged rooms.

Activity from every collaborator is in system.access.clean_room_events (Public Preview), with events such as CLEAN_ROOM_CREATED, RUN_NOTEBOOK_COMPLETED, CLEAN_ROOM_ASSETS_UPDATED and ASSET_REVIEW_CREATED (table reference). Join it to system.billing.usage on central_clean_room_id to see what each room costs. A short query we'd schedule weekly:

SELECT clean_room_name, event_type, COUNT(*) AS events, MAX(event_time) AS last_seen
FROM system.access.clean_room_events
WHERE event_time >= current_date() - INTERVAL 7 DAYS
GROUP BY ALL
ORDER BY clean_room_name, last_seen DESC;

An ASSET_REVIEW_CREATED you can't match to a named reviewer is the finding.

Marketplace, from the consumer side #

Marketplace listings include datasets, AI models, notebooks, apps and MCP servers. Underneath is OpenSharing, so an acquired dataset arrives as a catalog instead of an ingestion project. Some listings are instant once you accept the terms; others need provider approval or a transaction. Providers can also run private exchanges visible only to member consumers, which is the underused half: a company with many partners can publish to one exchange instead of negotiating a delivery per partner. Requesting access needs a workspace; reading the data afterwards doesn't have to happen in one.

MCP servers in Marketplace carry a permission trap. Installing one needs USE MARKETPLACE ASSETS on the metastore plus USE CATALOG, USE SCHEMA and CREATE SERVICE on the target, and callers then need EXECUTE on the registered MCP. End users don't need USE CONNECTION, and granting it lets them call the underlying connection directly, outside the tool allowlist you set. Our write-up on Meta's ads MCP server walks through the setup.

Sharing and collaboration on each platform

Capability Databricks AWS Azure GCP
Live table access without a copy OpenSharing, recipient reads your storage Data Exchange with Redshift datashares or S3 sets Purview data sharing or Fabric external sharing Analytics Hub linked datasets in BigQuery
Recipient needs the same platform No, open sharing serves any client Consumer needs an AWS account Recipient needs the matching Azure service Recipient needs BigQuery
Joint compute without disclosure Clean Rooms, notebook approval, up to ten parties AWS Clean Rooms Azure Confidential Clean Rooms BigQuery data clean rooms
Acquiring third-party data Marketplace, arrives as a catalog AWS Data Exchange Azure Marketplace, delivery varies Analytics Hub listings
Revocation and audit in one place Grants plus system.access.audit Per service, assembled Per service, assembled IAM plus BigQuery audit logs

The row we'd point at is the second. Every platform shares well inside itself; the difference shows when the partner isn't on your platform, which describes most partners. Our position is that the extract should be the exception, because a share can be revoked and every extract you've sent is still out there.