SHARE SDKs & Libraries: Python, JavaScript, R (2026)

SDKs overview

SHARE offers Software Development Kits (SDKs) to facilitate programmatic interaction with its data collaboration platform. These SDKs are designed to abstract the underlying RESTful API, providing language-specific constructs for common operations such such as authenticating users, managing shared datasets, and exchanging data in real time. The goal of the SDKs is to reduce the boilerplate code required for integration, allowing developers to focus on application logic rather than low-level API requests and responses. SHARE's developer documentation provides comprehensive guides for leveraging these tools to build applications that integrate with secure data workspaces and enable inter-organizational data exchange.

The platform's architecture supports secure data sharing by implementing features such as granular access controls and encryption. Developers utilizing the SDKs can integrate these security protocols into their applications without needing to implement them directly. The design principles emphasize ease of use for data scientists and engineers working with Python, JavaScript, and R environments, which are commonly used for data analysis and machine learning tasks. Further details on the core API capabilities are available in the SHARE API reference documentation.

Official SDKs by language

SHARE currently provides official SDKs for three programming languages: Python, JavaScript, and R. These SDKs are maintained by the SHARE development team and are the recommended method for integrating with the SHARE platform. Each SDK is tailored to the conventions and idioms of its respective language, aiming to provide a natural development experience.

These SDKs are designed to provide a consistent interface across languages for performing key operations such as authentication, data upload/download, managing permissions, and querying shared datasets. For specific versioning and compatibility information, consult the official SHARE documentation.

Installation

Installing the SHARE SDKs follows standard package management practices for each respective language. Ensure that you have the appropriate package manager (pip for Python, npm or yarn for JavaScript, and the R package manager for R) installed and configured in your development environment.

Python SDK

The Python SDK can be installed using pip, the Python package installer. It is recommended to use a virtual environment to manage dependencies.

# Create a virtual environment
python -m venv share_env
source share_env/bin/activate  # On Windows, use `share_env\Scripts\activate`

# Install the SHARE Python SDK
pip install share-sdk-python

Further details on Python environment setup are available in the Python venv documentation.

JavaScript SDK

The JavaScript SDK is available via npm and yarn. You can install it in your Node.js project or frontend application.

# Using npm
npm install @share/sdk-js

# Using yarn
yarn add @share/sdk-js

For browser-based applications, consider using a module bundler like Webpack or Rollup, as described in MDN's JavaScript modules guide, to include the SDK.

R SDK

The R SDK can be installed directly from CRAN (Comprehensive R Archive Network) using the install.packages() function in your R console.

# Install the SHARE R SDK
install.packages("shareR")

# Load the library in your R session
library(shareR)

For more advanced installation scenarios or development versions, consult the SHARE R SDK documentation.

Quickstart example

This quickstart demonstrates how to authenticate with the SHARE platform and perform a basic operation, such as listing available shared workspaces, using the Python and JavaScript SDKs. Before running these examples, ensure you have obtained your API key from the SHARE developer console.

Python quickstart: Listing workspaces

This Python example initializes the SDK with an API key and then retrieves a list of data workspaces accessible to the authenticated user.

import os
from share_sdk_python import ShareClient
from share_sdk_python.exceptions import ShareAPIError

# Replace with your actual API key, or set it as an environment variable
SHARE_API_KEY = os.getenv("SHARE_API_KEY", "YOUR_SHARE_API_KEY")

def list_workspaces():
    try:
        client = ShareClient(api_key=SHARE_API_KEY)
        workspaces = client.workspaces.list()

        print("Available SHARE Workspaces:")
        if workspaces:
            for ws in workspaces:
                print(f"  - ID: {ws.id}, Name: {ws.name}, Owner: {ws.owner}")
        else:
            print("  No workspaces found or accessible.")

    except ShareAPIError as e:
        print(f"Error connecting to SHARE: {e}")
    except Exception as e:
        print(f"An unexpected error occurred: {e}")

if __name__ == "__main__":
    list_workspaces()

JavaScript quickstart: Listing workspaces

This JavaScript example demonstrates similar functionality, using the @share/sdk-js package to authenticate and fetch workspaces. This can be run in a Node.js environment or bundled for a web application.

import { ShareClient } from '@share/sdk-js';

// Replace with your actual API key, or set it as an environment variable
const SHARE_API_KEY = process.env.SHARE_API_KEY || 'YOUR_SHARE_API_KEY';

async function listWorkspaces() {
  try {
    const client = new ShareClient({ apiKey: SHARE_API_KEY });
    const workspaces = await client.workspaces.list();

    console.log('Available SHARE Workspaces:');
    if (workspaces.length > 0) {
      workspaces.forEach(ws => {
        console.log(`  - ID: ${ws.id}, Name: ${ws.name}, Owner: ${ws.owner}`);
      });
    } else {
      console.log('  No workspaces found or accessible.');
    }
  } catch (error) {
    console.error('Error connecting to SHARE:', error.message);
  }
}

listWorkspaces();

Community libraries

While SHARE provides official SDKs, the open nature of its API allows for the development of community-contributed libraries and tools. These might include integrations with specific data visualization tools, connectors for popular data warehouses, or specialized utilities for data transformation. As of 2026, the primary focus remains on the official SDKs due to their comprehensive coverage and direct support from the SHARE team.

Developers interested in contributing to the SHARE ecosystem or developing their own libraries can refer to the SHARE developer portal and API reference for detailed specifications of the underlying REST API. Creating a community library typically involves understanding the API's authentication mechanisms, request/response formats (often JSON, as described in JSON.org's specification), and error handling. Community efforts are often shared through platforms like GitHub, enabling peer review and collaborative development.

It is advisable to check the official SHARE forums or community channels for any nascent or established community projects. While community libraries can offer valuable niche functionalities, users should verify their maintenance status, security practices, and compatibility with the latest SHARE API versions before relying on them in production environments.