HelloSign API SDKs & Libraries: Official & Community Support (2026)

SDKs overview

The HelloSign API provides software development kits (SDKs) to facilitate integration with various programming languages, enabling developers to incorporate e-signature capabilities directly into their applications. These SDKs abstract much of the complexity involved in making direct HTTP requests to the RESTful API, handling authentication, request formatting, and response parsing. HelloSign offers official SDKs for several popular languages, maintained by the HelloSign development team, to ensure compatibility with the latest API versions and features. The API itself is designed around REST principles, using standard HTTP methods and JSON payloads for data exchange, as detailed in the HelloSign API documentation. This approach makes it accessible even without an SDK, though the SDKs are recommended for faster and more robust development.

The SDKs are engineered to support core HelloSign API functionalities, including the creation and management of signature requests, template usage, embedded signing, and event notifications via webhooks. By using an SDK, developers can reduce the amount of boilerplate code required, focus on application logic, and benefit from language-specific conventions and error handling. For instance, an SDK might automatically convert data structures into the expected JSON format for API calls and parse JSON responses into native objects, simplifying data access and manipulation within the application's codebase. The availability of multiple SDKs addresses the diverse technology stacks used by developers, aligning with common development practices for integrating third-party services, as outlined by organizations like the W3C's developer resources.

Official SDKs by language

HelloSign provides official SDKs for several programming languages, designed to streamline the integration process. These SDKs are actively maintained to ensure compatibility with the latest API versions and to incorporate new features or improvements. The table below lists the primary official SDKs, their corresponding package managers, installation commands, and maturity status, reflecting their stability and ongoing support.

Developers typically choose an SDK based on their existing technology stack and language preferences, allowing for a consistent development experience within their projects. Each SDK is designed to reflect the idioms and conventions of its respective language, making it easier for developers to learn and use. Details on utilizing these SDKs are provided in the HelloSign developer documentation.

Installation

Installation of the HelloSign SDKs follows the standard practices for each language's ecosystem. The process typically involves using a package manager to add the SDK to your project dependencies. Below are specific installation instructions for the officially supported languages, ensuring developers can quickly set up their environments to begin interacting with the HelloSign API.

Python

For Python projects, the hellosign-sdk can be installed using pip, the standard package installer for Python:

pip install hellosign-sdk

It is recommended to install SDKs within a virtual environment to manage project dependencies effectively, as described in Python's virtual environment documentation.

Ruby

Ruby applications can integrate the hellosign-sdk gem using RubyGems:

gem install hellosign-sdk

For projects using Bundler, add the following line to your Gemfile and then run bundle install:

gem 'hellosign-sdk'

PHP

PHP projects typically use Composer for dependency management. To install the HelloSign PHP SDK:

composer require hellosign/hellosign-php-sdk

This command adds the SDK to your project's composer.json file and downloads the necessary files.

Node.js

For Node.js applications, the SDK is available via npm, the Node.js package manager:

npm install hellosign-sdk

Alternatively, if you prefer Yarn:

yarn add hellosign-sdk

Java

Java developers using Maven should add the following dependency to their pom.xml file:

<dependency>
    <groupId>com.hellosign</groupId>
    <artifactId>hellosign-java-sdk</artifactId>
    <version>YOUR_SDK_VERSION</version>
</dependency>

Replace YOUR_SDK_VERSION with the latest version available, which can be found in the official HelloSign API documentation.

For Gradle users, add to your build.gradle file:

implementation 'com.hellosign:hellosign-java-sdk:YOUR_SDK_VERSION'

.NET (C#)

For .NET projects, the SDK is distributed as a NuGet package. You can install it using the NuGet Package Manager Console:

Install-Package HelloSign.NET

Or via the .NET CLI:

dotnet add package HelloSign.NET

After installation, the SDK can be referenced in your C# code to access HelloSign API functionalities.

Quickstart example

This quickstart example demonstrates how to create a basic signature request using the Python SDK. The process involves initializing the client with your API key, defining the signers, and specifying the document to be signed.

Before running, ensure you have your HelloSign API key, which can be obtained from your HelloSign API settings, and replace the placeholder values.

import hellosign_sdk
from hellosign_sdk.hsclient import HSClient

# Initialize the HelloSign client with your API key
# Replace 'YOUR_API_KEY' with your actual HelloSign API key
client = HSClient(api_key='YOUR_API_KEY')

# Define the signature request parameters
signature_request_parameters = {
    'test_mode': 1,  # Set to 1 for testing, 0 for live requests
    'title': 'NDA with Client X',
    'subject': 'Please sign this Non-Disclosure Agreement',
    'message': 'Client X, please review and sign the attached NDA.',
    'signers': [
        {'name': 'Client X', 'email_address': '[email protected]'},
        {'name': 'Your Name', 'email_address': '[email protected]'}
    ],
    'files': ['/path/to/your/nda.pdf'],  # Replace with the actual path to your PDF file
    'cc_email_addresses': ['[email protected]']
}

try:
    # Send the signature request
    signature_request = client.send_signature_request(**signature_request_parameters)
    print(f"Signature request sent successfully! Request ID: {signature_request.signature_request_id}")
    print(f"Signers: {signature_request.signatures[0].signer_email_address} (status: {signature_request.signatures[0].status_code})")
    print(f"Signers: {signature_request.signatures[1].signer_email_address} (status: {signature_request.signatures[1].status_code})")

except hellosign_sdk.utils.api_exceptions.HSException as e:
    print(f"Error sending signature request: {e}")
    if e.response_data:
        print(f"API Error Details: {e.response_data}")

# Example of retrieving a signature request status (optional)
# request_id = signature_request.signature_request_id # Use the ID from the sent request
# status = client.get_signature_request(request_id)
# print(f"Status of request {request_id}: {status.status_code}")

This Python snippet initializes the HelloSign client, prepares a dictionary of parameters for the signature request, and then sends it. The test_mode: 1 parameter ensures that the request is handled in a sandbox environment and does not consume live signatures or send actual emails, which is useful for development and testing, aligning with common practices for HTTP status codes and API testing.

Community libraries

While HelloSign provides official SDKs for major programming languages, the open-source community may occasionally develop additional libraries or integrations. These community-contributed tools can offer specialized functionalities, alternative language support, or integrations with specific frameworks that are not officially supported. However, it is important to note that community libraries may not always keep pace with the latest API changes or maintain the same level of support as official SDKs.

As of 2026, HelloSign's primary focus for developer support remains on its official SDKs, which cover the most widely used programming languages. Developers seeking to integrate with HelloSign using a language or framework not covered by an official SDK can still do so by making direct HTTP requests to the HelloSign REST API endpoints. The API is well-documented with examples of request and response structures, allowing for custom client implementations. Before adopting a community library, it is advisable to verify its active maintenance, community support, and compatibility with the current HelloSign API version to ensure reliability and security in production environments.