SignRequest SDKs & Libraries: Integrating E-Signatures (2026)

SDKs overview

SignRequest provides a set of Software Development Kits (SDKs) and client libraries designed to facilitate the integration of its e-signature capabilities into various applications. These tools abstract the underlying RESTful API, allowing developers to interact with SignRequest services using language-specific constructs rather than directly managing HTTP requests and JSON parsing. The SDKs support common operations such as uploading documents, creating signature requests, retrieving signed documents, and managing templates, offering a programmatic interface for embedding document signing workflows.

The SignRequest API is designed to be accessible, leveraging standard HTTP methods and JSON payloads. The SDKs are built on this foundation, providing a more streamlined development experience across popular programming environments. This approach aims to reduce the effort required for developers to implement secure and compliant e-signature features, adhering to standards like eIDAS and SOC 2 Type II, as detailed in the SignRequest core API documentation.

Official SDKs by language

SignRequest maintains official SDKs for several programming languages, developed and supported by the SignRequest team. These SDKs are the recommended tools for integrating the SignRequest API, ensuring compatibility and access to the latest features. Each SDK provides idiomatic bindings for its respective language, simplifying API calls and response handling. The table below lists the primary official SDKs, their package names, common installation commands, and their general maturity status.

For detailed instructions and specific version information, developers should consult the SignRequest API documentation on SDKs and client libraries. The documentation also provides guidance on authentication methods, including API tokens, which are essential for securing API calls.

Installation

Installing SignRequest SDKs typically follows standard package management practices for each respective programming language. The process generally involves adding the SDK as a dependency to your project. Below are illustrative installation commands for some of the most commonly used languages:

Python

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

pip install signrequest-client

PHP

For PHP projects, Composer is the dependency manager used for installing the SignRequest client library.

composer require signrequest/signrequest-client-php

Node.js

Node.js developers can install the SignRequest client via npm (Node Package Manager).

npm install signrequest-client

Ruby

Ruby projects typically use Bundler or direct gem install for package management.

gem install signrequest-ruby-client

C# (.NET)

For .NET applications, the SignRequest client is available as a NuGet package, installed via the NuGet Package Manager Console.

Install-Package SignRequest.Client

Java

Java projects using Maven or Gradle will include the SignRequest SDK as a dependency in their pom.xml or build.gradle file, respectively. Specific dependency coordinates are available in the SignRequest SDK documentation for Java.

After installation, configuration typically involves providing your SignRequest API token, which authenticates your application's requests. This token can be generated from your SignRequest account settings.

Quickstart example

This example demonstrates how to create and send a basic signature request using the Python SDK. This snippet illustrates common steps: initializing the client, specifying document details, and sending the request. Additional parameters for signers, attachments, and callback URLs can be added as required by specific workflows, as outlined in the SignRequest API documentation on signature requests.

Python Example: Creating and Sending a Signature Request

import signrequest_client

# Configure API key authorization
configuration = signrequest_client.Configuration(host="https://signrequest.com/api/v1")
configuration.api_key['Authorization'] = 'YOUR_API_TOKEN'
configuration.api_key_prefix['Authorization'] = 'Token'

# Create an instance of the API client
api_client = signrequest_client.ApiClient(configuration)
api_instance = signrequest_client.SignRequestsApi(api_client)

try:
    # Create a NewDocument object (replace with your document's URL or base64 data)
    document_from_url = signrequest_client.DocumentFromUrl(url="https://example.com/document_to_sign.pdf", name="My Document to Sign")
    new_document = api_instance.documents_create(document_from_url)

    # Define signer information
    signer_email = "[email protected]"
    signer = signrequest_client.Signer(email=signer_email, order=1)

    # Create a SignRequest object
    signrequest_data = signrequest_client.SignRequest(document=new_document.url, 
                                                      signers=[signer], 
                                                      is_being_prepared=False, 
                                                      subject="Please sign this document",
                                                      message="Hello, please sign the attached document.")

    # Send the signature request
    result = api_instance.signrequests_create(signrequest_data)
    print(f"Signature Request created successfully. UUID: {result.uuid}")
    print(f"Signer URL: {result.signers[0].signing_url}")

except signrequest_client.ApiException as e:
    print(f"Error creating SignRequest: {e}")

This example demonstrates a basic flow. In a production environment, you would handle file uploads more robustly (e.g., converting local files to base64 or providing publicly accessible URLs), manage API tokens securely, and implement error handling and retries. Further capabilities, such as specifying signature fields, setting expiration dates, and handling multiple signers, are supported by expanding the SignRequest object with additional parameters.

Community libraries

While SignRequest provides official SDKs, the open-source community often contributes additional libraries, plugins, and integrations that extend functionality or support niche use cases not covered by official offerings. These community-driven projects can range from wrappers for less common languages to integrations with specific frameworks or content management systems.

Community libraries are typically found on platforms like GitHub or language-specific package repositories (e.g., PyPI, npm, Packagist). Developers interested in community contributions should search these platforms using terms such as SignRequest combined with the specific language or framework (e.g., "SignRequest Laravel" or "SignRequest GoLang"). When considering a community library, it is advisable to evaluate its maintenance status, community support, and alignment with the HTTP/1.1 Semantics and Content (RFC 7231) principles that RESTful APIs typically adhere to, to ensure reliability and security. Users should also review the source code for any security vulnerabilities or licensing implications before use.

The reliability and feature set of community libraries can vary significantly as they are not officially supported by SignRequest. For mission-critical applications, it is generally recommended to use the official SignRequest SDKs or directly interact with the SignRequest REST API.