Platform Overview & Partner Guide

ctSignature

B2B Document Signing Platform

A secure, API-first document signing service that enables businesses to integrate legally-binding electronic signatures into their own products and workflows.

Confidential — Partner Document
Version 1.0 — April 2026

Table of Contents

  1. Executive Summary
  2. Platform Overview & Value Proposition
  3. How It Works — End-to-End Flow
  4. Customer Dashboard — Complete Walkthrough
  5. API Integration Guide for Businesses
  6. Multi-Signer Workflows
  7. Document Templates & Reuse
  8. Security, Compliance & Audit Trail
  9. Pricing Tiers & Billing Model
  10. Webhook Notifications
  11. Embedded Signing (White-Label)
  12. Technical Architecture
  13. Roadmap & Future Features

1 Executive Summary

ctSignature is a B2B document signing platform that allows any business to add electronic signature capabilities to their existing products. Think of it as the engine behind the signing experience — businesses integrate via API or use our dashboard, and their customers sign documents through a secure, branded workflow.

💻

API-First Platform

RESTful API with simple authentication. Send a document for signing with a single API call. Integrate into any stack.

📊

Customer Dashboard

Self-service web portal for business customers to manage documents, API keys, billing, and account settings.

🔒

Enterprise-Grade Security

SHA-256 document hashing, device fingerprinting, geolocation tracking, and comprehensive audit trails.

💰

Flexible Billing

Subscription tiers with included documents, pay-as-you-go pricing, free trials, and Stripe-powered billing.

Target Market: Any business that needs document signing — real estate platforms, HR/onboarding tools, legal tech, insurance, healthcare, construction management, loan origination, property management, and more.

Key Differentiators

2 Platform Overview & Value Proposition

ctSignature serves as invisible infrastructure for other businesses. Their customers never need to know ctSignature exists — the signing experience lives inside the business's own product.

Who Uses ctSignature?

The Business (Our Customer)

  • Signs up via self-service dashboard
  • Gets API keys for their dev team
  • Integrates signing into their product
  • Manages documents and billing
  • Receives webhook notifications

The Signer (Their Customer)

  • Receives a signing link (URL or embedded)
  • Views the document in-browser
  • Signs with typed or drawn signature
  • Downloads signed PDF
  • No account or login required

Platform Architecture (Simplified)

1
Business App
Calls ctSignature API to create a signing session
2
ctSignature API
Stores document, generates secure tokens & URLs
3
Placement
Business positions signature fields on the PDF
4
Signing
Signer views PDF, applies signature, downloads
5
Webhook
Business notified, retrieves signed PDF via API

What a Business Gets

Capability Description
Dashboard Web portal to manage everything — documents, API keys, billing, account
REST API Programmatic access to create, track, and retrieve documents
API Keys Secure, hashed keys with prefix (ctds_live_) for easy identification
Document Templates Save a PDF with pre-positioned fields, send it to unlimited signers
Webhooks Real-time HTTP notifications for document events (signed, expired, viewed)
Embedded Signing Embed the signing experience in an iframe within their own application
Audit Trail Full forensic record: device fingerprint, IP, geolocation, timestamps, PDF hash
Signed PDF Download Retrieve completed PDFs with embedded signatures via API or dashboard

3 How It Works — End-to-End Flow

From document upload to signed PDF retrieval, here is the complete signing lifecycle.

Step 1: Create a Document

The business uploads a PDF and specifies the recipient. This can be done via the dashboard UI or the API.

// API Request POST /api/v1/documents Header: X-Api-Key: ctds_live_aBcDeFgHiJkLmNoPqRsTuVwXyZ012345678 // Form data recipientName: "Jane Smith" recipientEmail: "jane@example.com" file: [contract.pdf]
// API Response { "documentId": 142, "placementUrl": "https://sign.ctsignature.com/sign/place/abc123...", "signingUrl": "https://sign.ctsignature.com/sign/document/xyz789...", "placementToken": "abc123...", "secureToken": "xyz789...", "expirationDate": "2026-04-15T12:00:00Z" }

Step 2: Place Signature Fields

The business (or their operator) opens the Placement URL in a browser. The PDF is displayed with a drag-and-drop interface for positioning:

Fields are dragged, resized, and positioned on any page. When saved, the signing URL becomes active.

Step 3: Signer Receives the Link

The business sends the Signing URL to the signer (via email, SMS, in-app notification, etc.). No account is needed — the token in the URL grants access.

Step 4: Signer Signs the Document

The signer opens the URL and sees the PDF with highlighted signature areas. They:

  1. Review the document in the in-browser PDF viewer
  2. Choose a signature font or type their signature
  3. Enter their printed name
  4. Complete any required initials fields
  5. Click "Sign Document"

Behind the scenes, the system captures a comprehensive device fingerprint including browser fingerprint, canvas fingerprint, screen resolution, timezone, language, platform, IP address, and optional geolocation.

Step 5: Signed PDF Generated

The signature, printed name, timestamp, and audit stamp are rendered directly into the PDF. A SHA-256 hash is computed and stored for tamper detection. The signer can immediately download the completed PDF.

Step 6: Business Notified

A webhook (document.signed) fires to the business's configured endpoint with the document ID and status. The business can then retrieve the signed PDF via the API.

4 Customer Dashboard — Complete Walkthrough

The dashboard is the web interface where business customers manage every aspect of their ctSignature account. It's accessed at /dashboard/ and requires email/password authentication.

4.1 Registration & Login

New businesses create an account by providing:

Upon registration, the account starts with a free trial of 3 document signings (configurable by platform admins). After using all trial documents, the business must choose a subscription plan to continue.

Authentication: The dashboard uses JWT tokens (24-hour expiry). Sessions automatically redirect to login when expired. All API calls from the dashboard include the JWT in the Authorization header.

4.2 Overview Page

The home screen provides an at-a-glance summary:

4.3 Documents Page

Full document management with two main areas:

Send Document Form

Document List

4.4 API Keys Page

API keys are how businesses authenticate programmatic access. The page provides:

Security: API keys are hashed with SHA-256 before storage. The full key is shown exactly once at creation and cannot be retrieved again. This follows the same security model used by Stripe, GitHub, and other major platforms.

4.5 Account Settings Page

4.6 Billing Page (Stripe-Powered)

5 API Integration Guide for Businesses

Businesses integrate ctSignature into their applications using our REST API. Authentication is via API key in the X-Api-Key header.

Authentication

// Every API request includes the API key header GET /api/v1/documents X-Api-Key: ctds_live_aBcDeFgHiJkLmNoPqRsTuVwXyZ012345678

Core API Endpoints

Method Endpoint Description
POST /api/v1/documents Upload PDF and create a signing session
GET /api/v1/documents List all documents (paginated, filterable by status)
GET /api/v1/documents/{id} Get document details, status, and audit trail
GET /api/v1/documents/{id}/status Lightweight status check (polling-friendly)
DELETE /api/v1/documents/{id} Cancel/delete a document
GET /api/v1/documents/signed/{id} Download the completed signed PDF

Template Endpoints

Method Endpoint Description
POST /api/v1/templates Upload PDF and create a reusable template
POST /api/v1/templates/from-document/{id} Create template from an already-signed document
POST /api/v1/templates/{id}/send Send a template to a new recipient
GET /api/v1/templates List all templates

Webhook Endpoints

Method Endpoint Description
POST /api/v1/webhooks Register a webhook endpoint URL
GET /api/v1/webhooks List configured webhook endpoints
GET /api/v1/webhooks/{id}/deliveries View webhook delivery log and retry status

Example: Complete Integration in 4 API Calls

// 1. Create a document POST /api/v1/documents → { documentId, placementUrl, signingUrl } // 2. (Business opens placementUrl to position fields, or uses template) // 3. Send signingUrl to recipient via email/SMS/in-app // 4. After webhook notification (or polling), download signed PDF GET /api/v1/documents/signed/142 → [signed PDF binary]

Rate Limits

Scope Limit Window
General API (per tenant) 100 requests 1 minute
Signing operations 10 requests 1 minute
Document creation Based on plan tier Billing period

6 Multi-Signer Workflows

Many business documents require more than one signature — contracts with two parties, approvals with multiple stakeholders, agreements involving buyers, sellers, and witnesses. ctSignature supports both sequential and parallel multi-signer workflows out of the box.

Workflow Types

Sequential Signing

Signers complete the document in a defined order. Each signer can only access the document after all previous signers have completed. This is ideal for hierarchical approvals or when one party needs to review another's signature.

  • Signer 1 signs first
  • Signer 2 cannot access until Signer 1 is done
  • Each subsequent signer sees prior signatures on the PDF
  • Document status: pending → sent → partially_signed → signed

Parallel Signing

All signers receive their links immediately and can sign in any order, at any time. This is ideal when signers are independent parties who don't need to wait for each other.

  • All signing links are active simultaneously
  • Signers complete independently
  • Document is marked "signed" when the last signer completes
  • Each signer's signature is rendered onto the PDF as they sign

How Multi-Signer Works

1
Create Document
Upload PDF, add 2+ signers with names, emails, and roles
2
Place Fields
Position signature, name, stamp fields for each signer separately
3
Distribute Links
Each signer gets their own unique signing URL
4
Sign
Each signer signs their fields (order enforced if sequential)
5
Complete
Final PDF contains all signatures with individual audit trails

Key Features

Common Use Cases

Scenario Workflow Signers
Real estate purchase agreement Sequential Buyer → Seller → Agent (witness)
Lease agreement Sequential Tenant → Landlord
Business partnership agreement Parallel Partner A, Partner B, Partner C
Employee offer letter Sequential HR Manager → Employee
Multi-party NDA Parallel All parties sign independently
Loan agreement Sequential Borrower → Co-signer → Lender

Backwards compatible: Single-signer documents work exactly as before. Multi-signer is an additive feature — businesses choose single or multi-signer when creating each document.

7 Document Templates & Reuse

Templates are the most powerful feature for businesses that send the same type of document repeatedly — contracts, NDAs, onboarding forms, consent documents, etc.

How Templates Work

1
Upload PDF
Upload the master document once
2
Place Fields
Position signature, name, date, initials fields
3
Save Template
Template is saved with field positions locked in
4
Send to Signers
Send to unlimited recipients — no re-placement needed

Template Features

Use Cases

Industry Template Example Volume
Real Estate Lease agreement, disclosure forms Hundreds per month
HR / Onboarding Offer letters, NDAs, I-9 forms Per new hire
Legal Client engagement letters, retainers Per client
Healthcare Patient consent forms, HIPAA acknowledgments Per patient
Insurance Policy applications, claims forms Per policy
Construction Change orders, lien waivers, safety acknowledgments Per project

8 Security, Compliance & Audit Trail

Document signing requires trust. ctSignature implements multiple layers of security to ensure document integrity, signer identity verification, and comprehensive forensic audit trails.

Document Security

Feature Implementation
Document Integrity SHA-256 hash computed after signing. Any post-signing modification is detectable via hash comparison.
Token-Based Access Each document gets two unique 256-bit cryptographic tokens (placement + signing). No account needed to sign.
Constant-Time Comparison Token validation uses constant-time comparison to prevent timing attacks.
Automatic Expiration Tokens expire after a configurable period (default 72 hours). Background service nullifies expired tokens.
Path Traversal Prevention All file operations validate paths to prevent directory traversal attacks.
Tenant Isolation Every database query is scoped to the authenticated tenant. No cross-tenant data access is possible.

Signature Audit Trail

Every signature event captures the following data points for forensic verification:

Identity & Device

  • IP address
  • Browser user agent
  • Device fingerprint (FingerprintJS)
  • Canvas fingerprint
  • Screen resolution
  • Operating system / platform

Context & Verification

  • Geolocation (country, region, city, lat/lon)
  • Timezone and language
  • Signature font used
  • Exact UTC timestamp
  • Signature hash (SHA-256 of signature + device + timestamp)
  • Signed PDF hash (tamper detection)

API Security

Infrastructure Security

9 Pricing Tiers & Billing Model

ctSignature uses a hybrid pricing model: subscription tiers with included documents plus overage charges, and a pure pay-as-you-go option. All billing is powered by Stripe.

Free Trial

Every new account starts with a free trial of 3 document signings (configurable by platform admins). No credit card required. After using all trial documents, the business must select a plan to continue. Platform admins can also manually mark any account as "no charge" to bypass billing entirely.

Subscription Tiers

Starter
$29/mo
100 documents included
  • $0.50 per overage doc
  • Dashboard access
  • API access
  • Email support
Pay-As-You-Go
$0/mo
No monthly commitment
  • $1.00 per document
  • Dashboard access
  • API access
  • Pay only for what you use
Enterprise
Custom
Unlimited documents
  • Custom pricing
  • Everything in Pro
  • Priority support
  • SLA guarantees
  • Custom integrations

Billing Mechanics

Feature How It Works
Document counting A document is counted when created (uploaded + session started). Whether or not it gets signed, it counts toward the limit.
Billing period Monthly, aligned to the subscription start date
Overage billing Charged at the end of each billing period for documents exceeding the included amount
Plan changes Upgrades take effect immediately. Downgrades take effect at the next billing period.
Payment methods Credit/debit card via Stripe. Invoicing available for Enterprise.
No-charge override Platform admins can mark any tenant as "no charge" to bypass all billing checks

Tier Customization

All tiers are stored in the database and are fully admin-editable. Platform administrators can:

10 Webhook Notifications

Webhooks allow businesses to receive real-time HTTP notifications when events occur on their documents, eliminating the need to poll the API for status changes.

Supported Events

Event Trigger Use Case
document.signed A signer completes the signing process Update CRM, send confirmation, archive signed PDF
document.expired A document's signing link expires without being signed Send reminder, create new document, flag for follow-up
document.viewed A signer opens the signing page Track engagement, update status in business app

Webhook Payload Example

POST https://your-app.com/webhooks/ctsignature Content-Type: application/json X-Webhook-Signature: sha256=a1b2c3d4e5f6... { "event": "document.signed", "documentId": 142, "timestamp": "2026-04-12T15:30:00Z", "data": { "recipientName": "Jane Smith", "recipientEmail": "jane@example.com", "signedAt": "2026-04-12T15:30:00Z", "pdfHash": "e3b0c44298fc1c149afb..." } }

Security & Reliability

Configuration

Businesses configure webhooks via the dashboard or API:

11 Embedded Signing (White-Label)

Businesses can embed the ctSignature signing experience directly within their own application using an iframe, creating a seamless, branded experience for their end users.

How It Works

Redirect Mode (Default)

The signer is sent to a ctSignature-hosted URL. After signing, they can be redirected back to the business's app.

  • Simplest integration
  • No iframe configuration needed
  • Works on all devices and browsers

Embedded Mode (iframe)

The signing page loads inside an iframe within the business's own app. The signer never leaves the business's domain.

  • Seamless user experience
  • Business controls the surrounding UI
  • Requires domain allowlisting

Embedded Signing Setup

  1. Enable embedded signing in account settings
  2. Add allowed domains (e.g., https://app.yourbusiness.com)
  3. Embed the signing URL in an iframe:
    <iframe src="https://sign.ctsignature.com/sign/document/xyz789..." width="100%" height="800" frameborder="0" ></iframe>
  4. Listen for completion via webhook or postMessage events

Security: Embedded signing dynamically adjusts X-Frame-Options and Content-Security-Policy headers per tenant. Only domains explicitly allowlisted by the business can iframe the signing pages. All other domains are blocked with X-Frame-Options: DENY.

12 Technical Architecture

ctSignature is built on a modern, proven stack designed for reliability, security, and straightforward deployment.

Technology Stack

Layer Technology Why
Runtime ASP.NET Core 8.0 (C#) High performance, cross-platform, long-term support
Database MySQL 8.0+ Reliable, widely supported, excellent tooling
ORM Entity Framework Core 8.0 Code-first migrations, LINQ queries, type safety
PDF Engine PdfSharp 6.0 Open-source, .NET-native PDF manipulation
Payments Stripe Industry standard, comprehensive API, customer portal
Auth JWT + BCrypt Stateless tokens, secure password hashing
Frontend Vanilla JS + Tailwind CSS Zero build step, fast loading, no framework lock-in
PDF Viewer PDF.js (Mozilla) In-browser PDF rendering, no plugins needed
Fingerprinting FingerprintJS Browser/device identification for audit trail
Deployment Docker + Docker Compose Consistent environments, easy scaling

Multi-Tenancy Model

Database Schema (Key Tables)

Table Purpose Key Relationships
doc_tenants Business accounts Has many API keys, documents
doc_api_keys Hashed API keys Belongs to tenant
doc_documents Signing sessions Belongs to tenant, has signatures & initials
doc_signatures Signature + audit data Belongs to document
doc_initials_fields Initials field positions & completions Belongs to document
doc_templates Reusable document templates Belongs to tenant
doc_subscription_tiers Pricing plans Referenced by tenants
doc_usage_records Per-document billing tracking Belongs to tenant + document
doc_webhook_endpoints Configured webhook URLs Belongs to tenant
doc_webhook_deliveries Delivery log + retry tracking Belongs to webhook endpoint

Background Services

13 Roadmap & Future Features

ctSignature is being built in phases. Here's where we are and where we're headed.

Current Status

Phase Status Features
Core Signing Engine Complete PDF upload, field placement, signature capture, audit trail, signed PDF generation, hash verification
Phase 1: Dashboard & Auth Complete Tenant registration, JWT login, dashboard UI, document management, API key generation
Multi-Signer Workflows Complete Sequential and parallel signing, per-signer tokens and fields, co-signer progress, progressive PDF rendering
Phase 2: Multi-Tenant API In Progress API key auth middleware, tenant isolation, /api/v1 endpoints, per-tenant rate limiting
Phase 3: Billing (Stripe) Planned Subscription tiers, usage tracking, Stripe checkout, overage billing, admin tier management
Phase 4: Templates Planned Reusable templates, create-from-document, template management, send-from-template
Webhooks Planned Event notifications, HMAC signing, retry logic, delivery logs
Embedded Signing Planned iframe support, domain allowlisting, dynamic CSP headers

Future Considerations


Summary

ctSignature provides a complete, secure, and scalable document signing infrastructure that businesses can integrate into their products with minimal effort. With self-service onboarding, flexible pricing, comprehensive APIs, and enterprise-grade security, it's designed to be the signing engine that powers thousands of business workflows.

Questions? This document covers the complete platform as designed and in development. For technical deep-dives, API documentation, or partnership discussions, reach out to the ctSignature team.