NextSign API

Welcome to the NextSign API documentation.

NextSign is a comprehensive API platform that allows you to automate document creation, digital signing, case management, and secure document retrieval. It is designed for developers who want to integrate legally binding electronic signatures and document workflows directly into their applications.

With NextSign, you can generate contracts from templates, populate documents dynamically, send them for signing, track progress, and retrieve signed files — all through a secure and scalable API.

What You Can Build

Using the NextSign API, you can:

• Automate contract creation from reusable templates
• Populate documents dynamically using tags
• Send documents for electronic signing
• Track and manage signing cases
• Retrieve signed documents securely
• Convert DOCX templates to PDF with tag replacement

The API is suitable for CRMs, ERP systems, internal tools, and customer-facing platforms.

Core API Modules

Forms

Forms allow you to create reusable document templates that can be submitted multiple times with different data. They are ideal for contracts, agreements, and standardized documents.

With the Forms API, you can:

• Retrieve form details and configuration
• Fetch available tags for dynamic data population
• Submit forms to create signing cases
• Control reminders, expiration, access roles, and deletion policies

Cases

Cases represent individual signing processes created from forms or direct submissions.

Using the Cases API, you can:

• Retrieve multiple cases using filters
• Fetch specific cases by ID
• Monitor signing status and metadata
• Build dashboards and reporting tools

Documents

The Documents API provides secure access to files, uploads, and document conversion features.

You can:

• Upload larger files before case creation
• Generate pre-signed URLs for signed documents
• Retrieve completed contracts securely
• Convert DOCX files to PDF
• Replace tags dynamically before sending or previewing documents

Platform Guides

The platform guides explain how to build integrations that stay reliable in production:

• Use Authorization to set up API keys and companyId
• Use API Versioning to understand when to call v2 and when to call v3
• Use Rate Limits to design around the current 100 requests per minute limit
• Use Idempotency to understand request deduplication limits and webhook-safe handling
• Use Webhooks and Webhook Retry Logic to handle event delivery safely

Authentication

All API requests require authentication using a Bearer Token.

Authorization: Bearer YOUR_API_KEY

Creating an API Key

NextSign uses Bearer Token authentication, and your API key is the bearer credential you send with each request.

Steps to Create an API Key

1. Log in to your NextSign Dashboard
2. Navigate to Dashboard → Config → API Keys
3. Click Create API Key
4. Enter a name for the key (for example: Production API Key or Backend Service)
5. Click Generate

Once generated, your API key will be displayed only once.

Your companyId is also available on the API Keys page, shown at the top of the screen.

Using the API Key

Include the API key in the Authorization header of your API requests:

Authorization: Bearer YOUR_API_KEY

Example Request:

curl --location 'https://www.nextsign.dk/api/v2/{company}/cases/get' \
  -H 'Authorization: Bearer YOUR_API_KEY'

const response = await fetch(
  'https://www.nextsign.dk/api/v2/{company}/cases/get',
  {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer YOUR_API_KEY'
    }
  }
);

import requests

url = "https://www.nextsign.dk/api/v2/{company}/cases/get"
headers = {
    "Authorization": "Bearer YOUR_API_KEY"
}

response = requests.get(url, headers=headers)

Security Best Practices

Following security best practices is essential when working with API keys:

• Do not expose your API key in client-side code - API keys should only be used in server-side applications
• Never commit API keys to version control - Use environment variables or .env files (added to .gitignore)
• Rotate keys periodically and revoke unused ones from the dashboard
• Store keys securely using environment variables or a secrets manager (e.g., AWS Secrets Manager, Azure Key Vault, HashiCorp Vault)
• Use separate API keys for development, staging, and production environments
• Monitor API key usage regularly to detect any unauthorized access

Getting Started

Ready to integrate NextSign into your application? Here's how to get started:

1. Generate your API key from the NextSign dashboard
2. Choose an API module - Start with Forms, Cases, or Documents based on your use case
3. Make your first request - Test authentication and basic endpoints
4. Build your integration - Refer to the detailed endpoint documentation for each module

Explore the documentation sections for detailed information on each API module and endpoint.

Endpoint Reference

Setup

• Authorization - API key, bearer token, and companyId setup
• API Versioning - Understand how v2 and v3 endpoints are versioned
• Rate Limits - Plan around the current 100 requests per minute limit
• Idempotency - Build duplicate-safe request and webhook handling
• Test Environment - Work safely against the test environment

Forms

• Forms Get - Retrieve a form by ID
• Forms Tags - Retrieve available tags for a form
• Forms Submit - Submit a form and create a case

Cases

• Case List - List cases with filters
• Case Get Multiple - Fetch multiple cases by ID
• Case Get - Fetch a single case by ID
• Case Create - Create a new case
• Case Delete - Delete a case by ID

Documents

• Document Upload - Upload larger files before case creation
• Document Retrieve - Generate a pre-signed URL for a stored document
• Document Convert - Convert DOCX to PDF with tag replacement

Platform

• Webhooks - Receive event notifications
• Webhook Retry Logic - Understand retry timing and duplicate-safe consumers