DocuSign built its business on a simple insight: legally binding e-signatures save businesses enormous amounts of time vs wet signatures. That insight was right — but the pricing model charges accordingly. DocuSign pricing (2026): Personal: $10/month — 5 envelopes/month Standard: $25/user/month — unlimited envelopes Business Pro: $65/user/month — API access, templates, advanced fields Enterprise: Custom pricing — advanced authentication, compliance The problem is that API access — required for a

How to Migrate from DocuSign to Documenso in 2026

DocuSign Business Pro charges $65/user/month — $780/user/year. For a 5-person team that needs document signing, that's $3,900/year just to put signatures on PDFs. Documenso is the open source e-signature platform that provides the same core capabilities: template-based documents, multi-party signing workflows, email delivery, and an API for automation — for the price of a VPS ($5–15/month).

This guide covers deploying Documenso, recreating your DocuSign templates, migrating API integrations, and handling the transition period where existing DocuSign envelopes are still in flight.

Why Leave DocuSign?

DocuSign built its business on a simple insight: legally binding e-signatures save businesses enormous amounts of time vs wet signatures. That insight was right — but the pricing model charges accordingly.

DocuSign pricing (2026):

Personal: $10/month — 5 envelopes/month
Standard: $25/user/month — unlimited envelopes
Business Pro: $65/user/month — API access, templates, advanced fields
Enterprise: Custom pricing — advanced authentication, compliance

The problem is that API access — required for any automated workflow — is gated behind Business Pro. A developer who wants to programmatically send contracts pays $65/month minimum.

Documenso pricing:

Cloud (free tier): 5 documents/month
Cloud Pro: $30/month — unlimited documents, team features
Self-hosted: unlimited documents, unlimited templates, $5–15/month server

Step 1: Deploy Documenso

Documenso runs on Next.js with PostgreSQL. The Docker Compose setup takes about 15 minutes.

# docker-compose.yml
services:
  documenso:
    image: documenso/documenso:latest
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - NEXTAUTH_SECRET=your-nextauth-secret-minimum-32-chars
      - NEXTAUTH_URL=https://sign.yourdomain.com
      - NEXT_PUBLIC_WEBAPP_URL=https://sign.yourdomain.com
      - DATABASE_URL=postgresql://documenso:password@postgres:5432/documenso
      # SMTP for sending signature request emails
      - NEXT_PRIVATE_SMTP_HOST=smtp.resend.com
      - NEXT_PRIVATE_SMTP_PORT=587
      - NEXT_PRIVATE_SMTP_USERNAME=resend
      - NEXT_PRIVATE_SMTP_PASSWORD=re_your_resend_api_key
      - NEXT_PRIVATE_SMTP_FROM_ADDRESS=signing@yourdomain.com
      - NEXT_PRIVATE_SMTP_FROM_NAME=Your Company Signing
      # Storage (local or S3)
      - NEXT_PRIVATE_UPLOAD_TRANSPORT=local  # or 's3'
      # For S3 storage:
      # - NEXT_PRIVATE_UPLOAD_TRANSPORT=s3
      # - NEXT_PRIVATE_UPLOAD_BUCKET=your-bucket
      # - NEXT_PRIVATE_UPLOAD_REGION=us-east-1
      # - NEXT_PRIVATE_UPLOAD_ACCESS_KEY_ID=your-key
      # - NEXT_PRIVATE_UPLOAD_SECRET_ACCESS_KEY=your-secret
    volumes:
      - documenso_uploads:/app/public/uploads
    depends_on:
      - postgres
  postgres:
    image: postgres:15-alpine
    restart: unless-stopped
    environment:
      POSTGRES_DB: documenso
      POSTGRES_USER: documenso
      POSTGRES_PASSWORD: password
    volumes:
      - documenso_db:/var/lib/postgresql/data
volumes:
  documenso_uploads:
  documenso_db:

docker compose up -d

# Run database migrations
docker compose exec documenso pnpm prisma migrate deploy

Add HTTPS via Caddy:

sign.yourdomain.com {
    reverse_proxy localhost:3000
}

Visit https://sign.yourdomain.com and create the admin account.

Step 2: Configure Email Delivery

Documenso sends emails for every step of the signing workflow: initial request, reminders, completion confirmations. Configure a transactional email provider for reliable delivery.

Recommended providers (free tiers):

Resend: 3,000 emails/month free, excellent deliverability
SendGrid: 100 emails/day free
AWS SES: $0.10/1,000 emails after free tier

# Resend configuration:
NEXT_PRIVATE_SMTP_HOST=smtp.resend.com
NEXT_PRIVATE_SMTP_PORT=587
NEXT_PRIVATE_SMTP_USERNAME=resend
NEXT_PRIVATE_SMTP_PASSWORD=re_your_api_key_here
NEXT_PRIVATE_SMTP_FROM_ADDRESS=signing@yourdomain.com
NEXT_PRIVATE_SMTP_FROM_NAME=Acme Corp Signing

# For SES:
NEXT_PRIVATE_SMTP_HOST=email-smtp.us-east-1.amazonaws.com
NEXT_PRIVATE_SMTP_PORT=587
NEXT_PRIVATE_SMTP_USERNAME=AKID_your_ses_smtp_username
NEXT_PRIVATE_SMTP_PASSWORD=your_ses_smtp_password

SPF and DKIM: Set up email authentication records in your DNS to ensure signing request emails don't land in spam:

# SPF record (add to existing if you have one):
TXT  yourdomain.com  "v=spf1 include:resend.dev ~all"

# DKIM: Follow your provider's CNAME/TXT record instructions

Step 3: Recreate Document Templates

DocuSign templates define the document structure (PDF), field positions, signing order, and recipient roles. You'll need to recreate these in Documenso.

For each DocuSign template:

In DocuSign: Templates → Download to get the base PDF
In Documenso: Templates → Create Template
Upload the PDF
Add recipient roles (role names can match DocuSign roles for clarity)
Drag signature fields onto the document:
- Signature field (wet ink signature placeholder)
- Text field (for filling in text)
- Date field (auto-filled on signing)
- Checkbox field
- Initial field (for each page requiring initials)
Set signing order if multiple parties sign sequentially
Save template

Field mapping from DocuSign to Documenso:

DocuSign Field	Documenso Field
Signature	Signature
Initial	Initials
Date Signed	Date
Text	Text
Checkbox	Checkbox
Radio Group	Checkbox (individual)
Dropdown	Text (manual)
Title	Text

Step 4: Migrate API Integrations

If your workflows call the DocuSign API to create and send envelopes, migrate them to Documenso's REST API.

Get your API key:

Log in to Documenso → Settings → API Tokens
Create a new token with appropriate permissions

Creating and sending a document for signing:

// DocuSign API equivalent in Documenso

// Step 1: Create a document
const createDoc = await fetch('https://sign.yourdomain.com/api/v1/documents', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${DOCUMENSO_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    title: 'Software Consulting Agreement',
    recipients: [
      {
        name: 'Jane Smith',
        email: 'jane@clientcompany.com',
        role: 'SIGNER',
      },
      {
        name: 'Bob Johnson',
        email: 'bob@clientcompany.com',
        role: 'SIGNER',
      },
    ],
  }),
});

const { id: documentId } = await createDoc.json();

// Step 2: Upload the PDF
const formData = new FormData();
const pdfBuffer = fs.readFileSync('./contract.pdf');
formData.append('file', new Blob([pdfBuffer], { type: 'application/pdf' }), 'contract.pdf');

await fetch(`https://sign.yourdomain.com/api/v1/documents/${documentId}/upload`, {
  method: 'POST',
  headers: { 'Authorization': `Bearer ${DOCUMENSO_API_KEY}` },
  body: formData,
});

// Step 3: Send for signature
await fetch(`https://sign.yourdomain.com/api/v1/documents/${documentId}/send`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${DOCUMENSO_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    message: 'Please review and sign the attached consulting agreement.',
    sendEmail: true,
  }),
});

console.log(`Document sent! View at: https://sign.yourdomain.com/documents/${documentId}`);

Using templates via API:

// Create a document from a template
const response = await fetch('https://sign.yourdomain.com/api/v1/templates/create-document', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${DOCUMENSO_API_KEY}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    templateId: 'template_id_from_documenso',
    recipients: [
      {
        role: 'Client',  // Must match role name in template
        name: 'Alice Chen',
        email: 'alice@example.com',
      },
    ],
  }),
});

Webhook setup for completion events:

DocuSign calls a webhook when envelopes are completed. Documenso has equivalent webhook support:

// In your webhook handler:
app.post('/webhooks/documenso', (req, res) => {
  const { event, data } = req.body;

  if (event === 'document.completed') {
    const { documentId, recipients } = data;
    // Download the signed PDF, update your database, send confirmation email
    console.log(`Document ${documentId} fully signed by all parties`);
  }

  res.status(200).send('OK');
});

Settings → Webhooks → Create Webhook
URL: https://yourapp.com/webhooks/documenso
Events: document.completed, document.signed, document.declined

Step 5: Embed Signing in Your Application

DocuSign's embedded signing iFrame is a common integration pattern. Documenso provides a React component for the same purpose:

npm install @documenso/embed-react

import { EmbedDocumenso } from '@documenso/embed-react';

function SigningPage({ signingToken }) {
  return (
    <div className="signing-container">
      <EmbedDocumenso
        token={signingToken}
        host="https://sign.yourdomain.com"
        onSigningComplete={(data) => {
          console.log('Signing complete:', data);
          // Redirect to confirmation page
        }}
        onDocumentReady={() => {
          console.log('Document loaded in embed');
        }}
        css="border-radius: 8px; box-shadow: 0 4px 12px rgba(0,0,0,0.1);"
      />
    </div>
  );
}

// Get the signing token from your backend when creating the document:
const doc = await fetch('https://sign.yourdomain.com/api/v1/documents', {
  method: 'POST',
  headers: { Authorization: `Bearer ${API_KEY}` },
  body: JSON.stringify({ title: 'Agreement', recipients: [{ email, name, role: 'SIGNER' }] }),
});
const { recipients } = await doc.json();
const signingToken = recipients[0].token; // Pass to EmbedDocumenso

Step 6: Handle In-Flight DocuSign Envelopes

Don't cut over immediately if you have DocuSign envelopes that are partially signed or awaiting completion:

Export signed documents from DocuSign before canceling your plan — download all completed envelopes as PDFs with certificate of completion
Let pending envelopes complete on DocuSign before migration — don't send new requests from DocuSign
Archive historical data — store completed DocuSign PDFs and audit certificates in your document storage
Cut over new requests to Documenso once historical envelopes are resolved

Legal Validity

Documenso's signatures are legally valid under eIDAS (EU), ESIGN Act (US), UETA, and equivalent laws in most jurisdictions. The audit trail includes:

Signer email address
IP address at signing
Timestamp (UTC)
Device/browser information
Document hash (verifies document wasn't altered after signing)

For high-stakes contracts requiring identity verification (KYC/AML, notarized agreements), you may still need DocuSign's advanced authentication features (knowledge-based authentication, ID verification). These are not currently in Documenso's open source tier.

Cost Comparison

Usage	DocuSign Business Pro	Documenso Self-Hosted
1 user	$65/month	$5/month (VPS)
5 users	$325/month	$5/month
10 users	$650/month	$10/month
Documents/month	Unlimited	Unlimited
Annual savings (5 users)	—	$3,840/year

Operational Hardening for Production Documenso

Once Documenso is running and handling real signing workflows, a few operational practices separate a reliable production deployment from a fragile development setup.

Document storage strategy. The default Documenso configuration stores uploaded documents on the local filesystem inside the Docker volume. This works for a single-server setup but creates risks: a disk failure or accidental volume deletion loses all documents, and scaling to multiple application servers becomes impossible with local storage. For any production deployment handling documents with legal or business significance, migrate to S3-compatible object storage. Backblaze B2, Cloudflare R2, and AWS S3 all work with Documenso's S3 transport configuration. The cost is minimal — a signing workflow that generates a hundred PDFs per month might accumulate a few gigabytes of storage, costing under a dollar monthly on any of these providers.

Database backup cadence. Documenso's PostgreSQL database contains the audit trail for every signing event — signer email, IP address, timestamp, and document hash. This data has potential legal significance: it's the evidence that a document was signed, by whom, and when. Back up the database at minimum daily, with the backup stored in a separate geographic location from your application server. A simple approach is a daily cron job running pg_dump and uploading the compressed output to your object storage provider. Retain backups for at least seven years for documents with long legal relevance periods (contracts, employment agreements, real estate documents).

Email deliverability monitoring. Documenso's signing workflow is entirely email-driven: the initial signing request, reminders, and completion notifications are all sent via email. If your outbound email lands in spam, signers don't receive their requests, and documents sit unsigned indefinitely. Set up email authentication (SPF, DKIM, DMARC) for your sending domain before going live with external signers. Use a transactional email service (Resend, SendGrid, AWS SES) rather than direct SMTP from your server IP — fresh server IPs have poor deliverability reputations, while transactional email services have established delivery relationships with major email providers.

Webhook reliability. If your application integrates with Documenso's webhooks to trigger downstream actions on document completion (updating a CRM record, generating a follow-up task, triggering a billing event), those webhooks need a reliable receiver. Implement idempotent webhook handlers — if Documenso delivers the same webhook event twice (it may retry on HTTP errors), your handler should process it correctly the second time without creating duplicate records. Log all received webhook events with their Documenso event ID before processing, and skip processing if that event ID has already been handled.

Keeping Documenso updated. The Documenso team ships frequently. Security patches, new field types, and API additions are common. Subscribe to Documenso's GitHub releases for notifications. Before each update, check the release notes for database migration requirements — some updates include schema changes that require running migrations before or after the image update. The Docker Compose workflow for updates is typically: pull the new image, run docker compose up -d, then run docker compose exec documenso pnpm prisma migrate deploy if the release notes indicate schema changes.

When Documenso Fits vs. When DocuSign Still Makes Sense

The decision between Documenso and DocuSign isn't purely financial. There are workflow characteristics and compliance requirements where DocuSign's feature set remains genuinely superior, and understanding these boundaries helps you make the right call for your specific use case.

Documenso is the right choice when your signing workflows involve standard contracts between parties who have email addresses and don't require identity verification beyond email ownership. Employment agreements, consulting contracts, NDAs, software license agreements, client proposals — these are all well-served by Documenso's audit trail model (email address, IP, timestamp, document hash). The legal validity under ESIGN and UETA for these document types is the same whether signed with DocuSign or Documenso. If your team creates more than a few documents per month and you have any technical capacity to operate a server, the cost case for self-hosted Documenso is overwhelming — see the comparison table above.

DocuSign still makes sense when your signing workflows require advanced identity verification (knowledge-based authentication, government ID verification, or notarization), when your contracts are with regulated counterparties (financial institutions, government agencies) that specifically require DocuSign's compliance certifications by name, or when your legal team has already built DocuSign's specific audit certificate format into their evidence management workflows. DocuSign's ID Verification add-on provides identity assurance that is not currently available in Documenso's open source tier.

The middle ground is handled by Documenso Cloud's paid tier, which adds features beyond what the self-hosted open source version includes. For teams that want open source values (transparent codebase, no transaction fees, data portability) without self-hosting overhead, Documenso Cloud Pro at $30/month is often the right answer rather than DocuSign. The Documenso vs OpenSign comparison examines both platforms in detail for teams evaluating options in this category.

The broader point is that the e-signature market has a real open source alternative for the majority of use cases, and the legitimate exceptions (advanced identity verification, specific regulated workflows) are narrower than DocuSign's sales materials suggest. For most small and mid-sized businesses, the primary reason to stay on DocuSign is inertia rather than a genuine feature requirement that Documenso can't fulfill. The migration effort — realistically four to eight hours for a team with existing DocuSign templates and API integrations — pays for itself within the first month of avoided DocuSign licensing costs.

Workflow Automation with Documenso

One of the underappreciated advantages of self-hosted Documenso over DocuSign is the automation flexibility it enables. DocuSign's automation capabilities are gated behind the Business Pro tier ($65/user/month) and are further constrained by rate limits and API quotas that the cloud service enforces. With self-hosted Documenso, the API is yours — no rate limits beyond what your server can handle.

Automatic document generation. Many teams send the same contract type repeatedly with variable data — consulting agreements with different client names and rates, employment offers with different salary figures, NDAs for different counterparties. Rather than manually creating each document in Documenso's UI, build a simple workflow that populates a PDF template with variable data and submits it to the Documenso API automatically. The document creation API accepts a PDF upload and recipient list; generating the PDF from a template is handled by libraries like pdf-lib (JavaScript) or ReportLab (Python) that produce PDFs programmatically.

CRM-triggered signing workflows. When a deal reaches the "Contract Sent" stage in your CRM, automatically trigger a Documenso signing workflow for the appropriate contract template. When the document is fully signed, automatically advance the CRM deal stage to "Contract Signed" and create a follow-up task for the account owner. This workflow — CRM stage change triggers document send, document completion updates CRM — eliminates the manual coordination step that typically involves a person remembering to send the contract and then updating the CRM after confirmation arrives.

Document completion triggers. The webhook on document completion is the trigger point for downstream actions. When an NDA is signed, automatically provision access to your documentation system for the counterparty. When an employment agreement is signed, trigger your HR onboarding workflow. When a client contract is signed, create the first invoice in your billing system. These automations are straightforward to implement with Documenso's webhook events and a lightweight automation tool. For teams already using n8n for workflow automation, Documenso's webhook events map cleanly to n8n triggers, and the visual workflow builder makes it straightforward to add conditional logic based on which template was signed or which recipient completed the signature.

Volume processing. For use cases that involve high document volumes — lease agreements for property management companies, waivers for event organizers, consent forms for healthcare providers — the Documenso API handles batch creation efficiently. Script a loop that reads recipient data from a spreadsheet or database and creates signing workflows in parallel, respecting sensible concurrency limits. Operations that would be expensive on DocuSign's per-envelope pricing (or require a specific Enterprise tier) run on self-hosted Documenso at the cost of server compute only.

The combination of Documenso's straightforward REST API, webhook events, and self-hosted deployment gives engineering teams complete control over their document signing automation stack — a flexibility that DocuSign's cloud service restricts through both technical constraints and pricing tier gates.

See open source alternatives to Docusign on OSSAlt.

The SaaS-to-Self-Hosted Migration Guide (Free PDF)