Documentation - Document-Signer.com

Introduction to Document-Signer

Welcome to the Document-Signer documentation. This guide will help you get started with our digital document signing platform and show you how to make the most of its features.

Document-Signer is a comprehensive digital signature solution that enables businesses of all sizes to securely sign and manage documents online. Our platform provides:

Legally binding electronic signatures
Secure document management
Workflow automation
Detailed audit trails
API integration capabilities

This documentation is designed for both end-users and developers looking to integrate our signature capabilities into their own applications.

Quick Start Guide

Get up and running with Document-Signer in just a few minutes by following these steps:

1

Create an Account

Sign up for a Document-Signer account. New users can try our platform free for 14 days without entering payment information.

2

Upload a Document

From your dashboard, click "Upload Document" and select a file from your computer. We support PDF, Word, Excel, and image files.

3

Add Signature Fields

Use our document editor to drag and drop signature fields, text fields, checkboxes, and other form elements onto your document.

4

Add Recipients

Enter the email addresses of people who need to sign the document and assign fields to specific signers.

5

Send for Signature

Click "Send" to deliver the document to your recipients. You'll receive notifications as the document is viewed and signed.

Setting Up Your Account

Before you start sending documents for signature, take a few minutes to configure your account settings:

Profile Settings

Complete your profile information and upload your profile picture. This information will be visible to your document recipients.

Signature Settings

Create and save your default signature. You can draw your signature, type it, or upload an image of your signature.

Brand Customization

Professional and Enterprise plans allow you to customize the signing experience with your company logo, colors, and email templates.

Team Management

Add team members to your account and set appropriate permission levels to control who can send documents and access sensitive information.

Tip: Configure your notification preferences to control how you're alerted when documents are viewed, signed, or expire.

Sending Documents for Signature

Learn how to prepare and send documents for electronic signature:

Supported File Types

Document-Signer supports the following file formats:

PDF (.pdf)
Microsoft Word (.doc, .docx)
Microsoft Excel (.xls, .xlsx)
Text files (.txt)
Images (.jpg, .jpeg, .png)

Adding Form Fields

Drag and drop form fields onto your document to collect information and signatures:

Signature: Area where signers can draw, type, or upload their signature
Initials: For document sections requiring initial verification
Date: Automatically filled with the current date when signed
Text Field: For collecting typed information
Checkbox: For yes/no responses
Dropdown: For selecting from predefined options

Signing Order

You can set a specific signing order when your document requires multiple signatures. This ensures signers complete the document in the correct sequence.

Setting Expiration Dates

Define how long recipients have to sign your document. You can set expiration dates from 1 to 90 days after sending.

Creating Document Templates

Templates save time by allowing you to reuse document layouts and fields for recurring document types:

Creating a Template

From your dashboard, click "Templates" then "Create Template"
Upload a document or select an existing document
Add form fields and signature fields
Save the document as a template with a descriptive name

Using Templates

To use a template:

Select "Use Template" from your dashboard
Choose the template you want to use
Add recipient information
Make any necessary adjustments to fields
Send for signature

Sharing Templates

Templates can be shared with team members to ensure consistent document formats across your organization.

Signature Types

Document-Signer offers multiple signature options to meet various legal and usability requirements:

Standard E-Signature

Our standard electronic signature allows signers to:

Draw their signature using a mouse or touchscreen
Type their name and select a signature style
Upload an image of their handwritten signature

Digital Signatures

Digital signatures use certificate-based digital IDs for enhanced security and verification. These signatures include:

Embedded cryptographic information
Tamper-evident seals
Timestamp certification

Click-to-Sign

The simplest signature type, where signers click a button to indicate their agreement. Useful for basic acknowledgments and agreements.

Note: The appropriate signature type depends on your legal requirements, security needs, and user experience considerations.

Tracking & Notifications

Monitor the status of your documents and keep stakeholders informed throughout the signing process:

Document Dashboard

Your dashboard provides a real-time overview of all your documents with status indicators:

Draft - Document is being prepared
Sent - Document has been sent to recipients
Viewed - Recipient has opened the document
Signed - All recipients have signed
Completed - Document process is finished
Declined - Recipient declined to sign
Expired - Document signing period has ended

Email Notifications

Automatic notifications are sent for key document events:

When a document is sent to a recipient
When a recipient views a document
When a document is signed
When a document is completed by all parties
When a document is declined
When a document is about to expire

Reminder Settings

Configure automatic reminders for recipients who haven't signed. You can set:

Reminder frequency (daily, every 3 days, weekly)
Custom reminder messages
Maximum number of reminders to send

API Overview

The Document-Signer API allows you to integrate our digital signing capabilities into your own applications and workflows:

API Capabilities

Our RESTful API enables you to:

Create and send documents for signature
Manage templates
Track document status
Download signed documents
Manage users and teams
Retrieve audit trails

API Base URL

https://api.Document-Signer.com/v1

Response Format

All API responses are returned in JSON format and include a status code indicating success or failure.

Rate Limits

API requests are subject to rate limiting based on your subscription plan:

Professional: 100 requests per minute
Enterprise: 500 requests per minute

Note: API access is available on Professional and Enterprise plans only.

API Authentication

Secure your API requests using API keys and OAuth 2.0:

API Keys

Generate API keys from your account dashboard under "Developer Settings." Always keep your API keys secure and never expose them in client-side code.

Include your API key in the request header:

Authorization: Bearer YOUR_API_KEY

OAuth 2.0

For applications acting on behalf of users, implement OAuth 2.0 authentication:

Step 1: Redirect users to the authorization endpoint:

https://api.Document-Signer.com/oauth/authorize?client_id=YOUR_CLIENT_ID&response_type=code&redirect_uri=YOUR_REDIRECT_URI

Step 2: Exchange the authorization code for an access token:

POST https://api.Document-Signer.com/oauth/token
Content-Type: application/x-www-form-urlencoded

grant_type=authorization_code&code=AUTHORIZATION_CODE&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&redirect_uri=YOUR_REDIRECT_URI

Step 3: Use the access token in your API requests:

Authorization: Bearer ACCESS_TOKEN

Token Expiration

Access tokens expire after 24 hours. Use the refresh token to obtain a new access token without requiring user re-authentication.

Documents API

The Documents API allows you to programmatically create, send, and manage documents for signature:

Create a Document

POST /documents
Content-Type: application/json

{
  "name": "Contract Agreement",
  "file_url": "https://example.com/path/to/document.pdf",
  "recipients": [
    {
      "email": "[email protected]",
      "name": "John Doe",
      "role": "signer",
      "order": 1
    },
    {
      "email": "[email protected]",
      "name": "Jane Smith",
      "role": "cc",
      "order": 2
    }
  ],
  "fields": [
    {
      "type": "signature",
      "page": 1,
      "x": 100,
      "y": 200,
      "width": 200,
      "height": 50,
      "recipient_index": 0
    },
    {
      "type": "date",
      "page": 1,
      "x": 100,
      "y": 300,
      "width": 200,
      "height": 50,
      "recipient_index": 0
    }
  ],
  "expires_in_days": 30,
  "message": "Please sign this contract at your earliest convenience."
}

Get Document Status

GET /documents/{document_id}

Send Reminders

POST /documents/{document_id}/reminders
Content-Type: application/json

{
  "recipient_email": "[email protected]",
  "message": "Please sign the document as soon as possible."
}

Download Signed Document

GET /documents/{document_id}/download

Get Document Audit Trail

GET /documents/{document_id}/audit_trail

Templates API

The Templates API allows you to programmatically create and manage reusable document templates:

Create a Template

POST /templates
Content-Type: application/json

{
  "name": "NDA Template",
  "file_url": "https://example.com/path/to/nda.pdf",
  "fields": [
    {
      "type": "signature",
      "page": 1,
      "x": 100,
      "y": 200,
      "width": 200,
      "height": 50,
      "role": "signer"
    },
    {
      "type": "date",
      "page": 1,
      "x": 100,
      "y": 300,
      "width": 200,
      "height": 50,
      "role": "signer"
    }
  ]
}

List Templates

GET /templates

Get Template Details

GET /templates/{template_id}

Create Document from Template

POST /templates/{template_id}/documents
Content-Type: application/json

{
  "name": "NDA for Client XYZ",
  "recipients": [
    {
      "email": "[email protected]",
      "name": "Client Name",
      "role": "signer"
    },
    {
      "email": "[email protected]",
      "name": "Manager Name",
      "role": "cc"
    }
  ],
  "message": "Please sign this NDA before we proceed with the project.",
  "expires_in_days": 14
}

Webhooks

Webhooks allow your application to receive real-time notifications about document events:

Available Events

document.created - Document has been created
document.sent - Document has been sent to recipients
document.viewed - Recipient has viewed the document
document.signed - Recipient has signed the document
document.completed - All recipients have signed the document
document.declined - Recipient has declined to sign
document.expired - Document has expired

Creating a Webhook

POST /webhooks
Content-Type: application/json

{
  "url": "https://your-server.com/webhook-endpoint",
  "events": ["document.signed", "document.completed"],
  "secret": "your_webhook_secret"
}

Webhook Payload Example

{
  "event": "document.signed",
  "timestamp": "2023-08-15T14:32:10Z",
  "data": {
    "document_id": "doc_123456789",
    "document_name": "Contract Agreement",
    "signer": {
      "email": "[email protected]",
      "name": "John Doe"
    },
    "signed_at": "2023-08-15T14:30:45Z",
    "ip_address": "192.168.1.1"
  }
}

Verifying Webhook Signatures

For security, verify the webhook signature in the X-Document-Signer-Signature header:

// Node.js example
const crypto = require('crypto');

function verifyWebhookSignature(payload, signature, secret) {
  const hmac = crypto.createHmac('sha256', secret);
  const calculatedSignature = hmac.update(payload).digest('hex');
  return crypto.timingSafeEqual(
    Buffer.from(calculatedSignature, 'hex'),
    Buffer.from(signature, 'hex')
  );
}

Node.js Integration Example

This example demonstrates how to create and send a document for signature using Node.js:

const axios = require('axios');

// API configuration
const API_KEY = 'YOUR_API_KEY';
const API_BASE_URL = 'https://api.Document-Signer.com/v1';

// Set up axios instance with authentication
const apiClient = axios.create({
  baseURL: API_BASE_URL,
  headers: {
    'Authorization': `Bearer ${API_KEY}`,
    'Content-Type': 'application/json'
  }
});

// Function to send a document for signature
async function sendDocumentForSignature() {
  try {
    const document = {
      name: 'Employment Contract',
      file_url: 'https://your-server.com/documents/contract.pdf',
      recipients: [
        {
          email: '[email protected]',
          name: 'New Employee',
          role: 'signer',
          order: 1
        },
        {
          email: '[email protected]',
          name: 'HR Manager',
          role: 'signer',
          order: 2
        }
      ],
      fields: [
        {
          type: 'signature',
          page: 3,
          x: 100,
          y: 200,
          width: 200,
          height: 50,
          recipient_index: 0
        },
        {
          type: 'signature',
          page: 3,
          x: 100,
          y: 300,
          width: 200,
          height: 50,
          recipient_index: 1
        }
      ],
      message: 'Please sign your employment contract.',
      expires_in_days: 7
    };

    const response = await apiClient.post('/documents', document);
    console.log('Document created successfully:', response.data);
    return response.data;
  } catch (error) {
    console.error('Error creating document:', error.response ? error.response.data : error.message);
    throw error;
  }
}

// Check document status
async function checkDocumentStatus(documentId) {
  try {
    const response = await apiClient.get(`/documents/${documentId}`);
    console.log('Document status:', response.data);
    return response.data;
  } catch (error) {
    console.error('Error checking document status:', error.response ? error.response.data : error.message);
    throw error;
  }
}

// Usage
sendDocumentForSignature()
  .then(document => checkDocumentStatus(document.id))
  .catch(error => console.error('Operation failed:', error));

Python Integration Example

This example demonstrates how to create and send a document for signature using Python:

import requests
import json

# API configuration
API_KEY = 'YOUR_API_KEY'
API_BASE_URL = 'https://api.Document-Signer.com/v1'

# Set up headers with authentication
headers = {
    'Authorization': f'Bearer {API_KEY}',
    'Content-Type': 'application/json'
}

# Function to send a document for signature
def send_document_for_signature():
    document = {
        'name': 'Employment Contract',
        'file_url': 'https://your-server.com/documents/contract.pdf',
        'recipients': [
            {
                'email': '[email protected]',
                'name': 'New Employee',
                'role': 'signer',
                'order': 1
            },
            {
                'email': '[email protected]',
                'name': 'HR Manager',
                'role': 'signer',
                'order': 2
            }
        ],
        'fields': [
            {
                'type': 'signature',
                'page': 3,
                'x': 100,
                'y': 200,
                'width': 200,
                'height': 50,
                'recipient_index': 0
            },
            {
                'type': 'signature',
                'page': 3,
                'x': 100,
                'y': 300,
                'width': 200,
                'height': 50,
                'recipient_index': 1
            }
        ],
        'message': 'Please sign your employment contract.',
        'expires_in_days': 7
    }
    
    try:
        response = requests.post(
            f'{API_BASE_URL}/documents',
            headers=headers,
            data=json.dumps(document)
        )
        response.raise_for_status()
        print('Document created successfully:', response.json())
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error creating document: {e}')
        if hasattr(e, 'response') and e.response:
            print(e.response.text)
        raise

# Function to check document status
def check_document_status(document_id):
    try:
        response = requests.get(
            f'{API_BASE_URL}/documents/{document_id}',
            headers=headers
        )
        response.raise_for_status()
        print('Document status:', response.json())
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error checking document status: {e}')
        if hasattr(e, 'response') and e.response:
            print(e.response.text)
        raise

# Usage
if __name__ == '__main__':
    try:
        document = send_document_for_signature()
        check_document_status(document['id'])
    except Exception as e:
        print(f'Operation failed: {e}')

PHP Integration Example

This example demonstrates how to create and send a document for signature using PHP:

<?php

// API configuration
$API_KEY = 'YOUR_API_KEY';
$API_BASE_URL = 'https://api.Document-Signer.com/v1';

// Function to send a document for signature
function sendDocumentForSignature() {
    global $API_KEY, $API_BASE_URL;
    
    $document = [
        'name' => 'Employment Contract',
        'file_url' => 'https://your-server.com/documents/contract.pdf',
        'recipients' => [
            [
                'email' => '[email protected]',
                'name' => 'New Employee',
                'role' => 'signer',
                'order' => 1
            ],
            [
                'email' => '[email protected]',
                'name' => 'HR Manager',
                'role' => 'signer',
                'order' => 2
            ]
        ],
        'fields' => [
            [
                'type' => 'signature',
                'page' => 3,
                'x' => 100,
                'y' => 200,
                'width' => 200,
                'height' => 50,
                'recipient_index' => 0
            ],
            [
                'type' => 'signature',
                'page' => 3,
                'x' => 100,
                'y' => 300,
                'width' => 200,
                'height' => 50,
                'recipient_index' => 1
            ]
        ],
        'message' => 'Please sign your employment contract.',
        'expires_in_days' => 7
    ];
    
    $ch = curl_init($API_BASE_URL . '/documents');
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($document));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $API_KEY,
        'Content-Type: application/json'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode >= 200 && $httpCode < 300) {
        $responseData = json_decode($response, true);
        echo "Document created successfully:\n";
        print_r($responseData);
        return $responseData;
    } else {
        echo "Error creating document. HTTP Code: $httpCode\n";
        echo "Response: $response\n";
        return null;
    }
}

// Function to check document status
function checkDocumentStatus($documentId) {
    global $API_KEY, $API_BASE_URL;
    
    $ch = curl_init($API_BASE_URL . '/documents/' . $documentId);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Authorization: Bearer ' . $API_KEY,
        'Content-Type: application/json'
    ]);
    
    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);
    
    if ($httpCode >= 200 && $httpCode < 300) {
        $responseData = json_decode($response, true);
        echo "Document status:\n";
        print_r($responseData);
        return $responseData;
    } else {
        echo "Error checking document status. HTTP Code: $httpCode\n";
        echo "Response: $response\n";
        return null;
    }
}

// Usage
$document = sendDocumentForSignature();
if ($document && isset($document['id'])) {
    checkDocumentStatus($document['id']);
}
?>

Java Integration Example

This example demonstrates how to create and send a document for signature using Java:

import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

import org.json.JSONArray;
import org.json.JSONObject;

public class Document-SignerApiExample {

    private static final String API_KEY = "YOUR_API_KEY";
    private static final String API_BASE_URL = "https://api.Document-Signer.com/v1";
    private static final HttpClient httpClient = HttpClient.newBuilder()
            .version(HttpClient.Version.HTTP_2)
            .connectTimeout(Duration.ofSeconds(10))
            .build();

    public static void main(String[] args) {
        try {
            JSONObject document = sendDocumentForSignature();
            if (document != null && document.has("id")) {
                String documentId = document.getString("id");
                checkDocumentStatus(documentId);
            }
        } catch (Exception e) {
            System.out.println("Operation failed: " + e.getMessage());
            e.printStackTrace();
        }
    }

    private static JSONObject sendDocumentForSignature() throws IOException, InterruptedException {
        // Create document JSON
        JSONObject document = new JSONObject();
        document.put("name", "Employment Contract");
        document.put("file_url", "https://your-server.com/documents/contract.pdf");
        document.put("message", "Please sign your employment contract.");
        document.put("expires_in_days", 7);

        // Add recipients
        JSONArray recipients = new JSONArray();
        
        JSONObject recipient1 = new JSONObject();
        recipient1.put("email", "[email protected]");
        recipient1.put("name", "New Employee");
        recipient1.put("role", "signer");
        recipient1.put("order", 1);
        recipients.put(recipient1);
        
        JSONObject recipient2 = new JSONObject();
        recipient2.put("email", "[email protected]");
        recipient2.put("name", "HR Manager");
        recipient2.put("role", "signer");
        recipient2.put("order", 2);
        recipients.put(recipient2);
        
        document.put("recipients", recipients);

        // Add signature fields
        JSONArray fields = new JSONArray();
        
        JSONObject field1 = new JSONObject();
        field1.put("type", "signature");
        field1.put("page", 3);
        field1.put("x", 100);
        field1.put("y", 200);
        field1.put("width", 200);
        field1.put("height", 50);
        field1.put("recipient_index", 0);
        fields.put(field1);
        
        JSONObject field2 = new JSONObject();
        field2.put("type", "signature");
        field2.put("page", 3);
        field2.put("x", 100);
        field2.put("y", 300);
        field2.put("width", 200);
        field2.put("height", 50);
        field2.put("recipient_index", 1);
        fields.put(field2);
        
        document.put("fields", fields);

        // Create HTTP request
        HttpRequest request = HttpRequest.newBuilder()
                .POST(HttpRequest.BodyPublishers.ofString(document.toString()))
                .uri(URI.create(API_BASE_URL + "/documents"))
                .header("Content-Type", "application/json")
                .header("Authorization", "Bearer " + API_KEY)
                .build();

        // Send request and get response
        HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() >= 200 && response.statusCode() < 300) {
            JSONObject responseJson = new JSONObject(response.body());
            System.out.println("Document created successfully:");
            System.out.println(responseJson.toString(2));
            return responseJson;
        } else {
            System.out.println("Error creating document. HTTP Code: " + response.statusCode());
            System.out.println("Response: " + response.body());
            return null;
        }
    }

    private static JSONObject checkDocumentStatus(String documentId) throws IOException, InterruptedException {
        // Create HTTP request
        HttpRequest request = HttpRequest.newBuilder()
                .GET()
                .uri(URI.create(API_BASE_URL + "/documents/" + documentId))
                .header("Authorization", "Bearer " + API_KEY)
                .build();

        // Send request and get response
        HttpResponse response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        
        if (response.statusCode() >= 200 && response.statusCode() < 300) {
            JSONObject responseJson = new JSONObject(response.body());
            System.out.println("Document status:");
            System.out.println(responseJson.toString(2));
            return responseJson;
        } else {
            System.out.println("Error checking document status. HTTP Code: " + response.statusCode());
            System.out.println("Response: " + response.body());
            return null;
        }
    }
}

Getting Started

User Guide

API Reference

Examples