> For the complete documentation index, see [llms.txt](https://docs.concurrence.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.concurrence.com/developer-guide/classic-api/data-access/delta-sharing.md).

# Delta Sharing

Governed, read-only table sharing into your warehouse or lakehouse via the open Delta Sharing protocol.

Delta Sharing gives Concurrence a way to grant governed, read-only access to selected tables so you can consume the data directly inside your analytics platform or warehouse using an open sharing protocol.

{% hint style="info" %}
New to Delta Sharing?

Delta Sharing is an open protocol for secure data exchange across platforms and clouds. Providers expose read-only tables via a simple REST endpoint. Recipients use a small profile file (credentials plus endpoint) to query those tables directly from tools like pandas or Apache Spark, without copying data.

Learn more:

* [Overview](https://delta.io/sharing/)
* [Protocol spec](https://github.com/delta-io/delta-sharing/blob/main/PROTOCOL.md)
* [Quickstart](https://github.com/delta-io/delta-sharing#quick-start)
* [Python connector](https://github.com/delta-io/delta-sharing#python-connector)
* [Spark connector](https://github.com/delta-io/delta-sharing#apache-spark-connector)
* [Delta Sharing documentation](https://docs.delta.io/latest/delta-sharing.html)
  {% endhint %}

## Key Concepts

{% columns %}
{% column %}

* **Share**: the container your organization is granted access to. A share exposes one or more schemas.
* **Schema**: a logical grouping of tables within a share.
* **Table**: a read-only dataset you can query from supported tools.
  {% endcolumn %}

{% column %}

* **Profile file**: a JSON file with the endpoint and credentials that clients use.
* **Open protocol**: REST-based access to the underlying Parquet and Delta data.
  {% endcolumn %}
  {% endcolumns %}

## Access and Provisioning

Ask your Concurrence representative (via Slack) to provision a Delta Share for your organization and specify which tables you need. Delta Sharing is in beta, so schemas and operational policies can change.

You will receive one of the following:

* A share profile file (containing the share endpoint and credentials), or
* An endpoint URL plus recipient credentials, along with the list of shared schemas and tables.

## How You Use It

Most platforms support Delta Sharing natively or via an open-source connector. Import the provided share profile, or configure the endpoint and credentials per your platform's instructions. From there, you can browse the shared schemas and tables and query them like native read-only tables in your environment.

{% hint style="info" %}
Example workflows

* Connect your warehouse or lakehouse to read shared tables for BI dashboards.
* Consume curated datasets for ML feature engineering or offline evaluation.
* Join Concurrence-shared tables with your internal datasets without copying data.
  {% endhint %}

## Supported Clients

* **Python**: the `delta-sharing` library for pandas and PySpark.
* **Apache Spark**: the Delta Sharing Spark connector (SQL, Python, Scala, Java, R).
* **BI and ETL**: many tools integrate via the open protocol or vendor connectors.

## Quick Start

{% hint style="info" %}
Trying it quickly?

Use the public demo profile file to explore example datasets: [Open datasets profile](https://databricks-datasets-oregon.s3-us-west-2.amazonaws.com/delta-sharing/share/open-datasets.share)
{% endhint %}

{% tabs %}
{% tab title="Python (pandas)" %}

```bash
pip install delta-sharing
```

```python
import delta_sharing

profile_file = "/path/to/profile.share"  # e.g., ./open-datasets.share
table_url = f"{profile_file}#my_share.my_schema.my_table"

pdf = delta_sharing.load_as_pandas(table_url)
print(pdf.head())
```

{% endtab %}

{% tab title="PySpark" %}
Option A: the Python connector in PySpark (requires the Spark connector installed on the cluster).

```python
import delta_sharing

profile_file = "/path/to/profile.share"
table_url = f"{profile_file}#my_share.my_schema.my_table"

df = delta_sharing.load_as_spark(table_url)
df.createOrReplaceTempView("shared_table")
spark.sql("SELECT COUNT(*) FROM shared_table").show()
```

Option B: the Spark reader directly.

```bash
pyspark --packages io.delta:delta-sharing-spark_2.12:3.1.0
```

```python
profile_file = "/path/to/profile.share"
table_url = f"{profile_file}#my_share.my_schema.my_table"
df = spark.read.format("deltaSharing").load(table_url)
df.show()
```

{% endtab %}

{% tab title="Spark (Scala)" %}

```bash
spark-shell --packages io.delta:delta-sharing-spark_2.12:3.1.0
```

```scala
val profileFile = "/path/to/profile.share"
val tableUrl = s"$profileFile#my_share.my_schema.my_table"
val df = spark.read.format("deltaSharing").load(tableUrl)
df.selectExpr("count(*) as rows").show()
```

{% endtab %}
{% endtabs %}

{% hint style="info" %}
Table URL format: `<profile_file>#<share>.<schema>.<table>`. The profile file can live locally or in cloud storage (e.g., `s3a://...`). See the connector docs for supported path schemes.
{% endhint %}

## Governance and Operations

* **Scope**: shares are read-only and limited to the schemas and tables you request.
* **Security**: credentials and recipient tokens can be rotated. IP allowlisting is available on request.
* **Observability**: access and query activity are logged by Concurrence for security and auditing.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.concurrence.com/developer-guide/classic-api/data-access/delta-sharing.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.