DocuSign

Overview

DocuSign offers a suite of products primarily centered on electronic signatures and digital agreement management. Its core offering, DocuSign eSignature, allows individuals and organizations to sign documents digitally, replacing traditional paper-based processes. This functionality extends to various document types, including contracts, agreements, and forms, aiming to accelerate transaction times and reduce administrative overhead.

Beyond e-signatures, DocuSign's platform, known as the DocuSign Agreement Cloud, encompasses tools for automating the entire agreement lifecycle. This includes preparing, acting on, committing to, and managing agreements. Key components within this cloud include DocuSign CLM (Contract Lifecycle Management), which provides capabilities for contract generation, negotiation, workflow automation, and repository management. The platform is designed to integrate with existing business systems, enabling a more cohesive approach to document handling and approval processes across departments.

DocuSign is used by a range of users, from individuals and small businesses requiring basic e-signature capabilities to large enterprises with complex contract workflows and compliance requirements. It is particularly suited for industries that handle a high volume of regulated documents, such as financial services, healthcare, real estate, and legal sectors, due to its focus on security and compliance standards like HIPAA, GDPR, and FedRAMP. The platform's developer resources, including API documentation and multiple SDKs, support custom integrations and extensions of its core functionalities.

Key features

• Electronic Signatures: Enables legally binding digital signatures for documents across various devices.
• Document Workflow Automation: Automates the routing, review, and approval processes for agreements and contracts.
• Contract Lifecycle Management (CLM): Provides tools for contract generation, negotiation, version control, and storage.
• Template Management: Allows users to create and reuse document templates for recurring agreements.
• Audit Trails: Records a comprehensive history of document access, viewing, and signing events for compliance and verification purposes.
• Integrations: Offers pre-built connectors and an API for integration with CRM, ERP, and other business applications.
• Security and Compliance: Implements security measures and adheres to global compliance standards, including SOC 2 Type II and eIDAS.
• Mobile Access: Supports signing and managing documents from mobile devices through dedicated applications.

Pricing

DocuSign offers various plans tailored for individuals, small businesses, and enterprises. Pricing is typically based on the number of users, envelopes (documents sent for signature), and features included. Discounts are often available for annual billing.

Pricing as of May 28, 2026:

For detailed and up-to-date pricing information, refer to the official DocuSign pricing page.

Common integrations

• Salesforce: Integrates with Salesforce CRM for sending documents for signature directly from Salesforce records and updating record status upon completion.
• Microsoft (Dynamics 365, SharePoint, Outlook): Connects with Microsoft Dynamics 365 for sales and service agreements, SharePoint for document storage, and Outlook for email-based signing workflows.
• Workday: Enables e-signatures for HR documents, offer letters, and performance reviews within the Workday platform.
• SAP: Integrates with SAP solutions for streamlining procurement, sales, and legal processes.
• Oracle: Connects with Oracle applications for contract management and financial approvals.
• Google Workspace: Facilitates signing documents directly from Google Drive and Gmail.
• API and SDKs: Supports custom integrations with any system using its REST API and available SDKs for C#, Java, Node.js, PHP, Python, and Ruby.

Alternatives

• Adobe Acrobat Sign: Offers e-signature capabilities integrated within the Adobe Document Cloud ecosystem, focusing on PDF workflows.
• PandaDoc: Provides document automation, e-signatures, and workflow tools, often used for sales proposals and quotes.
• HelloSign: A Dropbox company, offering e-signatures and basic document workflows with a focus on ease of use and API integration.
• Zoho Sign: Part of the Zoho suite, providing e-signature solutions with integrated cloud storage and business applications.
• Microsoft 365 Electronic Signatures: While not a dedicated e-signature platform, Microsoft 365 offers tools and integrations that can support digital signing workflows, often in conjunction with third-party providers.

Getting started

To get started with DocuSign's eSignature API, you typically need to set up a developer account, obtain API credentials, and use one of the provided SDKs. The following Python example demonstrates how to send an envelope (document) for signature using the DocuSign eSignature REST API.

First, install the DocuSign Python SDK:

pip install docusign-esign

Then, you can use a script similar to this (ensure you replace placeholders with your actual credentials and file paths):

import base64
import os

from docusign_esign import ApiClient, EnvelopesApi, EnvelopeDefinition, Document, Signer, CarbonCopy, Recipients, OauthApiClient, RestApi, GrantTypes
from docusign_esign.client.api_exception import ApiException

# --- Configuration --- START
# Obtain these from your DocuSign developer account
CLIENT_ID = "YOUR_INTEGRATION_KEY"
IMPERSONATED_USER_ID = "YOUR_API_USER_ID" # GUID for the API user
PRIVATE_KEY_PATH = "/path/to/your/private_key.pem"
AUTH_SERVER = "account-d.docusign.com" # For developer accounts, use 'account-d.docusign.com'
BASE_PATH = "https://demo.docusign.net/restapi" # For developer accounts, use 'https://demo.docusign.net/restapi'
# --- Configuration --- END

# Path to the document you want to send for signature
DOCUMENT_PATH = "/path/to/document.pdf"

def get_access_token():
    api_client = OauthApiClient(host=AUTH_SERVER)
    try:
        # Read private key
        with open(PRIVATE_KEY_PATH, "r") as f:
            private_key = f.read()

        response = api_client.request_jwt_user_token(
            client_id=CLIENT_ID,
            user_id=IMPERSONATED_USER_ID,
            oauth_host=AUTH_SERVER,
            private_key_bytes=private_key.encode("ascii"), # Ensure key is bytes
            expires_in=3600, # Token validity in seconds
            scopes=["signature", "impersonation"]
        )
        return response.access_token
    except ApiException as e:
        print(f"Error getting access token: {e}")
        if e.body:
            print(f"Response body: {e.body}")
        return None

def send_document_for_signature():
    access_token = get_access_token()
    if not access_token:
        print("Failed to obtain access token.")
        return

    api_client = ApiClient(host=BASE_PATH)
    api_client.set_default_header("Authorization", f"Bearer {access_token}")

    envelopes_api = EnvelopesApi(api_client)

    # Read the document and encode it to base64
    with open(DOCUMENT_PATH, "rb") as file:
        content_bytes = file.read()
    base64_file_content = base64.b64encode(content_bytes).decode("utf-8")

    # Define the document
    document = Document(
        document_base64=base64_file_content,
        name="Example Document", # Name of the document in the envelope
        file_extension="pdf",
        document_id="1" # A unique ID for this document within the envelope
    )

    # Define the signer
    signer = Signer(
        email="[email protected]",
        name="John Doe",
        recipient_id="1",
        routing_order="1",
        client_user_id="1234" # Used for embedded signing
    )

    # Define where the signer should sign on the document (anchor text)
    # This is a simple example; usually you'd use more complex tab placements
    # For production, consider using 'tabs' object with specific coordinates or anchor strings
    signer.tabs = {
        "sign_here_tabs": [
            {
                "anchor_string": "/sn1/", # Anchor string to place signature field
                "anchor_units": "pixels",
                "anchor_x_offset": "-20",
                "anchor_y_offset": "10"
            }
        ]
    }

    # Define recipients
    recipients = Recipients(
        signers=[signer]
    )

    # Define the envelope
    envelope_definition = EnvelopeDefinition(
        email_subject="Please sign this document",
        documents=[document],
        recipients=recipients,
        status="sent" # Set to 'sent' to send the envelope immediately
    )

    try:
        # Create and send the envelope
        response = envelopes_api.create_envelope(
            account_id="YOUR_ACCOUNT_ID", # Your DocuSign Account ID
            envelope_definition=envelope_definition
        )
        print(f"Envelope sent successfully. Envelope ID: {response.envelope_id}")
    except ApiException as e:
        print(f"Error sending envelope: {e}")
        if e.body:
            print(f"Response body: {e.body}")

if __name__ == "__main__":
    # Ensure you have a PDF file at DOCUMENT_PATH and a private_key.pem
    # Also, replace all 'YOUR_...' placeholders with actual values.
    # For a real application, manage credentials securely (e.g., environment variables)
    send_document_for_signature()

Before running this code, ensure you have:

1. A DocuSign developer account.
2. An integration key (CLIENT_ID) and an API user ID (IMPERSONATED_USER_ID) from your DocuSign Admin console.
3. A private key (private_key.pem) generated for your integration key.
4. Your DocuSign Account ID.
5. A sample PDF document at the specified DOCUMENT_PATH. This document should contain the anchor string /sn1/ where the signature tab should be placed.

This example uses JWT Grant authentication, which is suitable for server-side applications. DocuSign provides additional guides and examples for other authentication methods and more complex workflows.