How packaged clean rooms bring RampID to your lakehouse
How packaged clean rooms bring RampID to your lakehouse
Databricks' LiveRamp Embedded Identity service brings identity resolution capabilities to the data platform, allowing customers to obtain a list of resolved RampID locally without exporting PII data to external services, while enabling governance through Unity Catalog.
Partner identity resolution used to mean sending your PII to the vendor
Historically on Databricks, to resolve customer records to a person-based ID such as RampID, a data team had to export PII to an outside service, wait for a match file, and load it back in. Each step added a pipeline to maintain, a copy of sensitive data to govern, and a delay before the results were usable. Packaged clean rooms disrupt this traditional pattern by removing the need for that round-trip.
LiveRamp Embedded Identity on Databricks brings the identity service to the data. Anyone can take advantage of LiveRamp's identity resolution solution without having their precious customer data leave their owned-storage. With minimal set-up, customers can receive a resolved list of RampIDs back in their environment where their analytics and AI workloads already run, all while maintaining Unity Catalog governance. These appended RampIDs to the customers’ data become the match key for high impact downstream use cases, for example:
- A publisher builds a sports-fan segment from authenticated viewing data in Databricks. With an approved match to an auto advertiser’s CRM, it can size an audience of sports fans who are in the advertiser’s prospect pool, excluding existing customers.
- An agency brings participating publishers’ streaming and digital exposure logs together with a retailer’s loyalty-linked purchases in a governed collaboration. Where the partners have compatible, authorized RampIDs, the agency can deduplicate reach across those buys and report how many exposed shoppers purchased. With a holdout, it can also estimate incremental sales and use that evidence to inform the next budget allocation.
What a packaged clean room is
A Databricks clean room is a secure environment where two or more parties run approved code across their combined data without revealing raw data or IP to each other. The computation happens in an isolated, Databricks-managed environment that none of the parties administers.
In a standard (approval-based) Databricks clean room, every collaborator is a peer. Collaborators can add data (tabular or unstructured) and/or code, and all parties have to approve the code before it can be run. Collaborators never see each other's data, but they do see the aliases of the tables shared in, along with their column names and types. This fits joint analysis, such as two companies measuring audience overlap together. Even in an approval-based room, a party can keep part of its logic private by packaging a volume, so approvers review the notebook that calls the library, not the library itself.
A packaged clean room extends the privacy to the entire analysis and fits a different relationship. One party, the identity provider (in this case, LiveRamp), ships an analysis as a product, and the other party, the customer, runs it against its own data. There is no approval step and neither party sees the other's data assets at all, not even table names or schemas. The provider can offer the same package to many customers, each in a separate clean room, and each customer gets a turnkey run with nothing to review. This allows for scalable deployments across multiple customers, and simplifies the customer’s experience.
For identity resolution cases, a packaged clean room makes particular sense as the split protects both sides. LiveRamp's identity graph and matching logic remain its intellectual property and invisible to the customer. The customer's PII and resolved results remain private to the customer.
Architecture walkthrough
There are three components, each with a clear role:
- LiveRamp (provider): provides identity resolution services (data) and code (notebooks, JARs) that perform resolution.
- The customer: creates the clean room, adds its input and configuration tables, triggers runs, and receives the results.
- Databricks (platform): hosts and isolates the clean room and manages the compute it runs on. The creator of the clean room is billed for this compute.
The central clean room
The central clean room is where everything happens. It's a Databricks-managed environment, separate from both the customer's and LiveRamp's workspaces, and no one from either company has administrative access to it.
- Location: The central clean room is created in the region chosen by whoever creates it. The customer creates the clean room, so it can place it in the same cloud and region as its data to help mitigate egress.
- Compute: Every run spins up serverless compute inside the central clean room and releases it when the run finishes. This compute scales vertically and horizontally to match the workloads needs automatically without leaving any idle compute.
- Data access: Each party's assets are shared into the central clean room read-only through OpenSharing. The data stays in its source storage, and no copy is delivered to the other collaborator.
- Firewalled storage: If the customer's tables are behind a storage firewall or private endpoint, SecureConnect brokers access through an isolated, Databricks-managed proxy so the clean room's compute can reach the data without opening the network.
How OpenSharing connects each party to the clean room
OpenSharing, formerly Delta Sharing, is the open sharing protocol that Databricks Clean Rooms are built on. Neither party copies its tables into the clean room. Instead, the customer and LiveRamp each add Unity Catalog assets, and OpenSharing grants the central clean room read-only access to them. Because OpenSharing shares tables live, without replication, each run reads the current version of the customer's input table rather than an extract from last week.
The connection leverages Databricks-to-Databricks sharing, so it keeps Unity Catalog governance on both sides: the provider controls which assets it exposes, the customer controls which tables it adds, and sharing activity is audited for both. OpenSharing also carries more than tables. It can share models, unstructured data, JAR files, private libraries, python wheels, and more. This flexibility is how LiveRamp is able to deliver all components of its identity resolution services.
A run, step by step
- The customer creates the LiveRamp packaged clean room in just a few clicks, with no infrastructure to provision or code to install. Once approved, LiveRamp will add their assets to the clean room. The customer sees the analysis names but not their contents.
- The customer adds an input table of touchpoints (such as names, emails, phone numbers, and addresses or device identifiers), attributes and a metadata table, following LiveRamp's documented format.
- The customer selects an output catalog where the results will land and triggers a run. LiveRamp's code runs on serverless compute in the central clean room and can read both parties' assets there.
- The resolved RampIDs are written to the customer's output schema, which only the customer can read. PII is stripped from the output before it's returned.
- The customer reads the output from its own Unity Catalog and carries the RampIDs into downstream work: customer 360 tables, audience building, activation, partner collaboration, and measurement.

Two output schemas: results and logs
A single run writes to two schemas:
- Output schema (customer only): holds the identity resolution results. It's shared only upon successful completion of run, only to the customer's workspace, and LiveRamp can't read it.
- Shared output schema (both parties): LiveRamp's code writes operational information here, such as run metrics and diagnostic logs. Each collaborator gets the shared output schema in its own workspace and reads it from its own Unity Catalog. This is shared during the execution of the run, regardless of the final run status.
Both are delivered via the same OpenSharing mechanism to their respective (customer/provider)-owned environments, into the catalogs specified at set-up, which can be found within the Catalog Explorer - Shares received section. These can be queried and leveraged immediately. For long-term (beyond 30 days) use, these tables will need to be copied down into a customers’ own cloud storage.
Shared run history and audit trail
Both the customer and LiveRamp can see the history of every run, including its status, timing, and the notebook that ran. Because the customer owns the data and LiveRamp owns the code, neither side has the full picture alone when a run fails. A shared view of run status, together with the shared output schema, lets both teams troubleshoot from the same facts without exposing data. Clean room activity is also recorded in each party’s system tables (system.access.clean_room_events), allowing for an audit trail.
Identity resolution where your data already lives
Packaged clean rooms turn identity resolution into something a data team runs rather than a pipeline it maintains. LiveRamp ships its identity resolution logic as a product, the customer runs it against live, governed data through OpenSharing, and the central clean room keeps each party's data and code private from the other.
The result is a RampID table in the customer's own Unity Catalog, ready for customer 360, audience building, activation, partner collaboration, and measurement. There are no exports to schedule, no match files to wait on, and no extra copies of PII to govern.
Getting started
- Let your LiveRamp and Databricks account team know you’d like to leverage the embedded identity packaged clean room approach.
- If your source storage is behind a firewall or private endpoint, configure SecureConnect and update your storage firewall rules.
- Prepare your customer data and metadata tables in the format LiveRamp specifies.
- Create the LiveRamp packaged clean room (Catalog > Share > Clean Rooms > select the LiveRamp tile under “Identity Resolution Providers”), configure your output schema, add your tables, and run it.
For full setup steps, see LiveRamp's guide, "Perform RampID identity resolution in Databricks," and the Databricks packaged clean rooms documentation.
FAQ
What is a packaged clean room in Databricks?
A packaged clean room is a Databricks Clean Rooms mode in which one party, the provider, supplies an analysis and the other party, the customer, runs it against its own data without seeing the code. Neither party can see the other's data assets, and the code runs on serverless compute in a Databricks-managed central clean room that neither party administers. LiveRamp Embedded Identity uses this mode: LiveRamp provides the identity graph and resolution code, and the customer runs it to receive RampIDs.
How is a packaged clean room different from a standard Databricks clean room?
In a standard, approval-based clean room every collaborator is a peer: anyone can add data or notebooks, approvers can read the notebook source, and every notebook needs approval before it runs. In a packaged clean room only the provider adds code, the customer sees notebook and JAR names but not their contents, and there is no approval step because the customer cannot review the code. The customer alone triggers runs and receives the output, while both parties see run history and a shared output schema for logs.
Does LiveRamp see my data when I run identity resolution in a Databricks clean room?
No. Your tables stay in your own cloud storage, OpenSharing gives the central clean room read-only access under Unity Catalog governance, and the resolved RampIDs are written to an output schema only you can read. LiveRamp sees the run status in the shared run history and the shared output schema, where its code writes metrics and logs that you receive too. LiveRamp's code does call LiveRamp's identity service to authenticate, and the clean room's egress network policy, shown on the Security tab, governs what else it can reach.
What do I need to run LiveRamp Embedded Identity on Databricks?
A LiveRamp agreement with Identity API credentials, a Unity Catalog workspace, and the CREATE CLEAN ROOM privilege. You prepare an input table of PII touchpoints and a metadata table holding your LiveRamp credentials and run settings in the format LiveRamp documents, then create the clean room from the LiveRamp tile under Identity Resolution Providers and choose a central clean room region. If your storage sits behind a firewall or private endpoint, enable SecureConnect first. Output tables are retained for 30 days, so copy results you want to keep into your own catalog.
Who pays for a Databricks clean room, and how is it billed?
The creator of the clean room is billed for the compute. Compute is billed at Jobs Serverless rates and starts only for each run, so there is no idle environment to maintain.
Ready to bring RampID to your lakehouse?
If you already work with LiveRamp, ask your LiveRamp representative about Embedded Identity on Databricks, then follow LiveRamp's guide to prepare your tables and create the clean room. If you are new to Databricks Clean Rooms, start with the packaged clean rooms documentation, or explore the LiveRamp Identity Resolution and Translation listing on Databricks Marketplace to learn more about the offering. If you aren't a current LiveRamp customer or need more information reach out to [email protected].
Source: Databricks Blog · databricks.com