Introduction to Chaindoc Chaindoc is a blockchain-powered platform for electronic signatures and document management. Secure, compliant, and developer-friendly solution for modern businesses. What is Chaindoc? Chaindoc is a comprehensive solution for managing documents, electronic signatures, and team collaboration. Built with blockchain technology, it provides immutable document verification, legally binding e-signatures, and enterprise-grade security. Blockchain verification for document authenticity Legally binding electronic signatures with compliance Developer-friendly APIs and SDKs Enterprise-grade security and encryption Real-time notifications via webhooks Key Features Blockchain Verification Every document published on Chaindoc is automatically verified on blockchain networks (Ethereum, Polygon, BSC, Arbitrum). This creates an immutable record that proves document authenticity and prevents tampering. Electronic Signatures Legally binding e-signatures compliant with eIDAS, ESIGN Act, and UETA Multiple signature types: simple, advanced, and qualified Multi-party signing workflows Sequential or parallel signing orders Deadline management and automatic reminders Document Management Version control with complete audit trail Support for PDF, Office documents, images, and videos Granular access control (private, public, team, restricted) Metadata and hashtag organization Full-text search capabilities Developer Tools RESTful API with comprehensive documentation TypeScript SDKs for Node.js backend and web frontend Embedded signing interface for seamless integration Webhooks for real-time event notifications Sandbox environment for testing Team Collaboration Role-based access control (Owner, Admin, Member, Viewer) Team workspaces and shared documents Activity logs and audit trails KYC/Identity verification integration with Sumsub How It Works Upload Document Upload your document via web interface or API. Supports PDF, Office files, images, and videos. Create Signature Request Add recipients and configure signing workflow. Set deadlines and custom messages. Signers Receive Notification Recipients get email notification with secure signing link or embedded interface. Document Signing Signers authenticate via OTP, review document, and apply electronic signature. Blockchain Verification Signed document is automatically verified on blockchain for immutable proof. Completion All parties receive the signed document with blockchain certificate. Use Cases Legal & Compliance Contracts, NDAs, employment agreements, and legal documents with blockchain-verified authenticity. Real Estate Property agreements, lease contracts, and transaction documents with immutable records. Financial Services Loan agreements, investment documents, and compliance forms with regulatory compliance. Healthcare Patient consent forms, medical records, and HIPAA-compliant document management. Enterprise Internal approvals, HR documents, vendor agreements, and automated workflows via API. Architecture Chaindoc uses a multi-layered architecture combining traditional cloud infrastructure with blockchain technology: Web Application - React-based SPA with Next.js REST API - Node.js backend with rate limiting and authentication Database - PostgreSQL for structured data, S3 for file storage Blockchain Layer - Smart contracts on Ethereum, Polygon, BSC, Arbitrum Message Queue - Event-driven architecture for webhooks and notifications CDN - Global content delivery for fast document access Security & Compliance End-to-end encryption (AES-256) SOC 2 Type II certified infrastructure GDPR, eIDAS, ESIGN Act, UETA compliant Regular security audits and penetration testing Two-factor authentication (2FA) IP whitelisting for API keys Getting Started Ready to begin? Choose your path: Quick Start - Get your first document signed in 5 minutes Installation - Set up SDKs for your development environment API Documentation - Dive into the REST API reference SDKs - Explore Node.js Server SDK and Embed SDK for web apps Start with the Quick Start guide for a hands-on walkthrough Explore the API Documentation for integration details Join our developer community on GitHub Contact [support@chaindoc.io](mailto:support@chaindoc.io) for enterprise inquiries

Introduction

Quick Start Guide Get up and running with Chaindoc in under 10 minutes. This guide covers both web interface and API integration for developers. For End Users A Chaindoc account (sign up for free at chaindoc.io) A document ready to sign (PDF, DOC, or image) Email addresses of signers Step-by-Step: Your First Signature Sign Up Create your free account at [app.chaindoc.io](https://app.chaindoc.io). Verify your email address. Upload Document Click 'New Document' and upload your file. Supports PDF, Office documents, images (up to 50MB). Add Document Details Enter document name, description, and tags for organization. Choose access level (private, team, or public). Create Signature Request Click 'Request Signatures', add recipient emails, set deadline, and customize message. Configure Signature Flow Choose signing order (parallel or sequential), enable KYC if needed, select notification preferences. Send Request Review and send. Recipients receive email with secure signing link. Track Progress Monitor signing status in real-time. Receive notifications when signatures are collected. Download Signed Document Once complete, download the signed document with blockchain certificate. Document is blockchain-verified for authenticity All parties have copies of the signed document Immutable audit trail is created Legally binding signature with compliance For Developers Integrate Chaindoc into your application using our REST API and SDKs. 1. Get API Keys API access requires a Business plan subscription Navigate to Settings → API Access in your dashboard Create Public Key (pk_) for frontend and Secret Key (sk_) for backend 2. Install SDK Choose the SDK based on your use case: 3. Create Your First Document via API 4. Create Signature Request 5. Integrate Signing Interface (Frontend) For embedded signing in your web application: 6. Track Status and Handle Events 7. Set Up Webhooks (Optional) Receive real-time notifications for events: Complete Workflow Example Here's a complete end-to-end example combining all steps: Next Steps Read the Installation guide for detailed SDK setup Explore API Documentation for complete endpoint reference Check SDKs documentation for framework-specific examples (React, Vue, Angular) Set up Webhooks for real-time event notifications Review Security Best Practices for production deployment Use sandbox environment (pk_test_/sk_test_) for development Store API keys in environment variables, never in code Enable debug mode during development for detailed logs Test with small files first to understand the workflow Join our GitHub community for code examples and support Common Questions How long does blockchain verification take? Blockchain verification typically completes in 1-5 minutes depending on the network. Documents are available immediately, verification happens asynchronously. Can I test without a paid plan? Yes! Free plan includes web interface access. API access requires Business plan, but you can use sandbox environment for testing. Are signatures legally binding? Yes, Chaindoc signatures comply with eIDAS, ESIGN Act, and UETA regulations. Blockchain verification provides additional legal evidence. What file formats are supported? PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX, TXT, JPG, PNG, GIF, WEBP, SVG, MP4, AVI, MOV, WMV. Maximum file size: 50MB.

Quick Start

Installation Complete installation guide for Chaindoc SDKs. Set up Server SDK for backend integration and Embed SDK for frontend signing interface. Prerequisites Chaindoc account with API access (Business plan required) Node.js 18+ for Server SDK Modern browser support for Embed SDK (Chrome, Firefox, Safari, Edge) API keys (Public and Secret) from dashboard Server SDK Installation The Server SDK is used for backend integration - document management, signature requests, and blockchain verification. Step 1: Install Package Step 2: Configure Environment Variables Create a .env file in your project root: Never commit .env files to version control Add .env to .gitignore Use different keys for development, staging, and production Rotate keys regularly for security Step 3: Initialize SDK Step 4: Verify Connection Embed SDK Installation The Embed SDK provides a signing interface for web applications. Works with any JavaScript framework. Step 1: Install Package Step 2: Configure Environment Variables Step 3: Initialize in Your App Framework-Specific Setup Next.js (App Router) Next.js (Pages Router) Nuxt 3 Angular TypeScript Configuration Both SDKs include full TypeScript definitions. No additional @types packages needed. Environment Configuration Development Environment Production Environment Verification Test your installation with these verification steps: Check SDK Version console.log(ChaindocEmbed.version); // Should output version number Verify API Connection Test health check endpoint to confirm API keys are valid Test File Upload Upload a small test file to verify media endpoints work Initialize Embed SDK Initialize SDK and check browser console for any errors Troubleshooting Module Not Found Error TypeScript Errors If you see TypeScript errors, ensure your tsconfig.json has correct module resolution settings and Node.js types are installed. API Key Issues 401 Unauthorized - Invalid or expired API key 403 Forbidden - Business plan required for API access Keys must match environment (test keys for staging, live keys for production) Public keys (pk_) for frontend, Secret keys (sk_) for backend only Next Steps Review Quick Start guide for your first integration Check API Documentation for endpoint reference Explore SDKs documentation for advanced features Set up Webhooks for real-time notifications Join developer community on GitHub for support Use separate API keys for each environment Enable debug mode during development for detailed logs Monitor SDK version and update regularly Test thoroughly in staging before production deployment

Installation

Electronic Signatures Create legally binding electronic signatures with ease. Chaindoc provides a simple and secure way to add electronic signatures to your documents. Our signatures are compliant with international standards and backed by blockchain verification for maximum legal validity and audit trail integrity. Signature Types Chaindoc supports multiple signature types to meet different legal and business requirements: Simple Electronic Signature (SES) Basic digital signature for low-risk documents and internal agreements: Click-to-sign functionality Email verification required Suitable for NDAs, internal approvals, and informal agreements Quick signing process without authentication delays Basic audit trail with timestamp and IP address Advanced Electronic Signature (AES) (Upcoming in 2026) Enhanced security for business-critical documents: Multi-factor authentication (SMS, authenticator app, or email) Identity verification before signing Suitable for contracts, employment agreements, and vendor agreements Comprehensive audit trail with signer authentication details Blockchain-verified certificate of completion Qualified Electronic Signature (QES) (Upcoming in 2026) Highest level of signature with equivalent legal status to handwritten signatures: Certified by trusted certificate authorities ID verification with government-issued documents Compliant with eIDAS, ESIGN Act, and UETA Required for highly regulated industries (legal, financial, healthcare) Hardware security module (HSM) protected certificates Immutable blockchain proof of signature Legal Compliance Chaindoc signatures comply with major electronic signature regulations worldwide: International Standards eIDAS (Electronic Identification and Trust Services) - European Union ESIGN Act (Electronic Signatures in Global and National Commerce Act) - United States UETA (Uniform Electronic Transactions Act) - United States PIPEDA (Personal Information Protection and Electronic Documents Act) - Canada Electronic Transactions Act - Australia Information Technology Act - India Compliance Requirements To ensure legal validity, Chaindoc implements: Clear intent to sign (explicit consent required) Consent to do business electronically Association of signature with the record Record retention and tamper-proof storage Signer identity verification Audit trail with timestamps and IP addresses Blockchain-backed proof of integrity Signature Workflow Creating a Signature Request Follow these steps to request signatures: Upload your document (PDF, Word, or image formats) Add signers with their email addresses and names Assign signing order (sequential or parallel signing) Place signature fields on the document Configure signature type and authentication requirements Add custom message and deadline (optional) Send signature request Signature Field Types Customize your documents with various field types: Signature - Electronic signature field Initials - For initialing pages or clauses Date Signed - Automatically filled with signing date Text Field - For names, titles, or custom information Checkbox - For consent or acknowledgment Dropdown - For selecting from predefined options Radio Buttons - For exclusive choice selection Signing Order Options Sequential - Signers receive document in specified order Parallel - All signers receive document simultaneously Hybrid - Combine sequential and parallel signing groups Conditional - Next signer depends on previous signer's action Signer Experience Receiving a Signature Request When invited to sign, recipients: Receive email notification with secure link Click link to access document (no login required for basic signatures) Authenticate identity if required (MFA, SMS code, etc.) Review document with highlighted signature fields Add signature, initials, and fill required fields Verify information and confirm signature Receive signed copy via email instantly Signature Creation Options Signers can create signatures using: Typed signature with multiple font styles Draw signature with mouse or touchscreen Upload image of handwritten signature Mobile signature with finger or stylus Saved signature (for returning users) Blockchain Verification Every signature is secured with blockchain technology: Immutable Proof Document hash recorded on blockchain at signature time Unique transaction ID for each signature event Tamper-proof verification certificate Independent verification available to all parties Permanent record that survives organizational changes Verification Process Anyone can verify a signed document: Access verification portal at verify.chaindoc.com Upload signed document or enter verification code System calculates document hash Hash compared against blockchain record Verification result shows: document integrity, signature dates, signer details Download verification certificate (optional) Audit Trail & Certificate Comprehensive Audit Trail Every signature includes detailed audit information: Document sent timestamp and sender details Email delivery and open timestamps for each recipient Document view timestamps (when signers accessed document) Authentication method and success/failure logs Signature timestamps with millisecond precision IP addresses and device information Geolocation data (if enabled) Document completion timestamp Blockchain transaction ID and block number Certificate of Completion Automatically generated certificate includes: Document title and unique document ID All parties with roles (sender, signers, viewers) Complete timeline of all events Signature images and typed names Security measures applied (authentication methods) Blockchain verification information Legal disclaimer and terms of service reference QR code for instant verification Advanced Features In-Person Signing Collect signatures in person with a single device: Host mode for collecting multiple signatures Each signer signs on the same device Individual email verification per signer Ideal for events, conferences, or office signing All signatures recorded with separate audit trails Bulk Send Send the same document to multiple recipients: Upload CSV file with recipient information Merge fields for personalization (name, company, etc.) Send to hundreds of signers simultaneously Individual tracking for each document Bulk status reporting and reminders Reminders & Notifications Automatic reminders every 3 days (configurable) Custom reminder messages Expiration warnings before deadline Real-time notifications for document events Email and in-app notification options Signature Decline & Void Handle signature refusals and document cancellation: Signers can decline with reason Sender receives immediate notification Sender can void documents before completion Voided documents marked as cancelled in audit trail All parties notified of decline or void action Best Practices Document Preparation Use clear document titles for easy identification Optimize PDFs (compress large files, remove security) Place signature fields in logical positions Label fields clearly (e.g., 'Client Signature', 'Manager Approval') Add instructions or descriptions for complex fields Test signing flow before sending to important recipients Security Recommendations Use Advanced or Qualified signatures for legal documents Enable MFA for sensitive agreements Set appropriate expiration dates (typically 7-30 days) Require authentication for high-value contracts Keep signed documents in secure storage Regularly backup signed documents and certificates Verify blockchain records for critical documents Communication Tips Include clear subject lines in signature requests Add personalized messages explaining the document Provide context and deadline information Include contact information for questions Use professional tone in all communications Follow up with phone call for urgent documents Troubleshooting Common Issues Solutions for frequent signing problems: **Signer didn't receive email**: Check spam/junk folder, verify email address, resend request **Link expired**: Sender can extend deadline and resend **Authentication failed**: Verify contact information matches request, try alternative authentication **Cannot draw signature on mobile**: Ensure device allows touch input, try typed signature **Document won't load**: Check internet connection, try different browser, clear cache **Signature field missing**: Contact sender to add required fields Support Resources Email support: [support@chaindoc.io](mailto:support@chaindoc.io) API documentation for developers

Electronic Signatures

Document Management Organize and manage your documents efficiently. Keep all your documents in one secure place. Upload, organize, and share documents with your team using granular permissions, blockchain-verified storage, and comprehensive audit trails. Document Lifecycle Chaindoc manages documents through their entire lifecycle, from creation to archival: Document States Draft - Document being prepared, not yet sent Pending - Sent for signatures, awaiting completion In Progress - Partially signed, some signatures remaining Completed - All signatures collected, document finalized Declined - Signer rejected the document Voided - Sender cancelled before completion Expired - Deadline passed without completion Archived - Completed document moved to long-term storage Automatic State Transitions Documents automatically move through states based on actions: Draft → Pending (when sent to signers) Pending → In Progress (first signature received) In Progress → Completed (all signatures collected) Any → Voided (sender cancels) Any → Declined (signer rejects) Pending/In Progress → Expired (deadline reached) Document Organization Folder Structure Organize documents with flexible folder hierarchies: Create unlimited folders and subfolders Organize by department, project, client, or custom criteria Move documents between folders with drag-and-drop Shared folders for team collaboration Personal folders for individual users Template folders for reusable documents Archive folders for completed documents Smart Filters & Views Find documents quickly with powerful filtering: Filter by status (pending, completed, expired) Filter by date range (created, modified, signed) Filter by signer or sender Filter by document type or template Filter by tags and custom metadata Save custom filter combinations as views Quick access to recently viewed documents Search Capabilities Advanced search across all documents: Full-text search within document content Search by document title, description, or metadata Search by signer name or email Search by custom fields and tags Blockchain transaction ID search Boolean operators for complex queries Search results with highlighting and previews Document Upload & Import Supported File Formats PDF (.pdf) - Recommended format Microsoft Word (.doc, .docx) Microsoft Excel (.xls, .xlsx) Microsoft PowerPoint (.ppt, .pptx) Images (.jpg, .png, .gif, .tiff) Text files (.txt, .rtf) OpenDocument formats (.odt, .ods, .odp) Upload Methods Drag and drop files into browser Select files from computer Import from cloud storage (Google Drive, Dropbox, OneDrive) Mobile camera capture for on-the-go scanning API upload for programmatic integration Bulk upload of multiple documents Email-to-Chaindoc for email attachments Automatic Conversion Documents automatically converted to PDF for consistency: Word, Excel, PowerPoint converted to PDF Images converted to PDF with OCR (text recognition) Preserve formatting, fonts, and layout Original file available for download Conversion happens instantly on upload Document Storage & Security Secure Storage AES-256 encryption at rest TLS 1.3 encryption in transit Geographically distributed storage (multi-region) Automatic backups every 6 hours 99.99% uptime SLA GDPR, HIPAA, and SOC 2 compliant storage Data residency options (EU, US, Asia) Blockchain Anchoring Every document anchored to blockchain for tamper-proof verification: Document hash recorded on blockchain at upload Additional hashes at each state change Immutable proof of document existence and integrity Independent verification available to all parties Survives even if Chaindoc service discontinues Version Control Track document changes with automatic versioning: Automatic version creation on upload of same document View version history with timestamps Compare versions side-by-side Restore previous versions if needed Each version has unique blockchain hash Audit trail shows who uploaded each version Access Control & Permissions Permission Levels Granular permissions for documents and folders: Owner - Full control, can delete and manage permissions Editor - Can edit, send for signature, and manage document Viewer - Read-only access, can view and download Signer - Can view and sign assigned documents Commenter - Can view and add comments (no editing) No Access - Explicitly blocked from viewing Sharing Options Share with specific users by email Share with entire team or department Share with external parties (clients, vendors) Time-limited access (expires after set period) Password-protected sharing links View-only links for public sharing Expiring links for temporary access Access Audit Trail Complete visibility into document access: Who accessed the document and when What actions were taken (view, download, edit) IP address and device information Geolocation data (if enabled) Permission changes history Failed access attempts Export audit logs for compliance Document Metadata & Tags Standard Metadata Automatically captured metadata: Document title and description Created date and creator Modified date and last modifier File size and page count Document status and state Signers and recipients Completion date (if applicable) Blockchain transaction IDs Custom Metadata Add custom fields for your business needs: Create custom field types (text, number, date, dropdown) Required or optional fields Department, project, or client identifiers Contract value, expiration dates Custom categories and classifications Integration with external systems (CRM, ERP) Bulk edit metadata across multiple documents Tags & Labels Add unlimited tags to documents Color-coded labels for visual organization Autocomplete from existing tags Filter and search by tags Bulk tagging for multiple documents Tag suggestions based on document content Team-wide tag libraries Document Retention & Archival Retention Policies Automate document lifecycle with retention rules: Set retention periods by document type (e.g., 7 years for tax documents) Automatic archival after retention period Legal hold to prevent deletion during litigation Compliance with industry regulations (GDPR, HIPAA, SOX) Automatic deletion after archival period (optional) Retention policy templates for common scenarios Override policies for specific documents Archival Storage Long-term storage for completed documents Reduced access frequency (cold storage) Lower cost than active storage Instant retrieval when needed Maintained blockchain verification Export archives for external backup Compliance reporting from archived documents Document Export & Download Export Options Download individual documents as PDF Bulk download as ZIP archive Export with audit trail and certificate Export metadata to CSV or JSON Export to cloud storage (Google Drive, Dropbox) Scheduled exports for backup API export for system integration Download Controls Control who can download documents: Disable downloads for sensitive documents Watermark downloads with user information Track all download events in audit trail Limit number of downloads per user Expire download links after use Require additional authentication for downloads Document Analytics Usage Statistics Track document and system usage: Total documents by status Average time to completion Most active users and teams Document volume trends over time Popular document types and templates Storage usage and growth API usage statistics Compliance Reports Documents awaiting signature Expired or declined documents Access audit reports User activity reports Retention policy compliance Blockchain verification reports Custom report builder Integration & Automation Cloud Storage Integration Two-way sync with Google Drive Dropbox integration for file access OneDrive and SharePoint connection Box enterprise storage Automatic upload to cloud after signing Folder mapping between systems Business System Integration Salesforce - Attach to opportunities and accounts HubSpot - Link to deals and contacts Microsoft Dynamics - CRM integration SAP - ERP document management NetSuite - Financial document workflow Zapier - Connect to 5000+ apps Custom API integrations Best Practices Document Organization Establish clear folder structure before bulk uploads Use consistent naming conventions Apply tags and metadata immediately Create templates for recurring document types Archive old documents regularly Set up retention policies early Review and clean up folders quarterly Security & Compliance Review access permissions monthly Revoke access for departed employees immediately Use time-limited sharing for external parties Enable download watermarking for sensitive documents Monitor audit trails for unusual activity Regular backup of critical documents Verify blockchain hashes for important documents Performance Optimization Compress large files before upload Use bulk operations for multiple documents Archive completed documents to reduce clutter Use saved filters instead of repeated searches Schedule exports during off-peak hours Clean up drafts and cancelled documents Troubleshooting Common Issues **Upload fails**: Check file size (max 100MB), verify internet connection, try different browser **Cannot find document**: Use search instead of browsing, check filters and folder access **Permission denied**: Contact document owner or administrator for access **Slow performance**: Clear browser cache, reduce number of documents in view, archive old files **Download not working**: Check popup blockers, verify download permissions, try different browser **Version conflict**: Multiple users editing simultaneously - coordinate with team

Document Management

Team Management Collaborate with your team effectively. Invite team members, assign roles, and manage permissions to ensure smooth collaboration across your organization. Chaindoc's team management features enable secure collaboration while maintaining compliance and audit trails. Team Structure Organization Hierarchy Build your organization structure in Chaindoc: Organization - Top-level entity for your company Departments - Organize teams by function (Legal, HR, Sales, etc.) Teams - Smaller groups within departments Projects - Temporary groups for specific initiatives Nested structures - Departments can contain sub-departments Multi-organization support - Manage multiple entities from one account Team Types Private Teams - Visible only to members Public Teams - Visible to entire organization Cross-functional Teams - Members from multiple departments Client Teams - Include external collaborators Temporary Teams - Auto-archive after project completion User Roles & Permissions Global Roles Organization-wide roles with different permission levels: **Owner** - Full administrative control, billing, and user management **Admin** - User management, team creation, and system settings **Manager** - Team and document management within assigned areas **Member** - Standard user with document creation and signing rights **Guest** - Limited access for external collaborators **Auditor** - Read-only access with audit trail visibility Permission Matrix What each role can do: Owner: All permissions including account deletion Admin: Manage users, teams, billing, integrations, security settings Manager: Create teams, manage team members, approve documents Member: Create/send documents, sign, view team documents Guest: View and sign assigned documents only Auditor: View all documents and audit trails, generate reports Custom Roles Create custom roles for specific needs: Define granular permissions (view, create, edit, delete, approve) Assign to specific departments or teams Document type-specific permissions (e.g., only HR can access employee contracts) Temporary role assignments with expiration dates Role templates for common scenarios Compliance roles with restricted access User Management Adding Users Multiple ways to add team members: Email invitation with custom welcome message Bulk import via CSV file Single Sign-On (SSO) auto-provisioning Domain-based auto-join (users with @company.com) API-based user creation Self-service registration with admin approval User Profiles Each user has a comprehensive profile: Name, email, and contact information Profile photo and bio Job title and department Team memberships Assigned roles and permissions Document activity statistics Last login and activity status Two-factor authentication status User Lifecycle Management Onboarding - Automated welcome emails and training materials Active - Full access to assigned resources Suspended - Temporary access removal (vacation, investigation) Deactivated - Permanent access removal (departed employees) Transfer ownership - Reassign documents to another user Archive user data - Maintain audit trail after departure Team Collaboration Shared Workspaces Collaborate on documents within team spaces: Team folders with automatic access for members Shared document templates Team-wide tags and metadata Collaborative editing and commenting Team activity dashboard Shared signature workflows Team analytics and reports Communication Features Document comments and mentions (@username) Internal notes (not visible to signers) Team announcements and notifications Activity feed for team actions Email notifications for document events In-app messaging for urgent matters Integration with Slack, Microsoft Teams Approval Workflows Route documents through approval chains: Define multi-step approval processes Sequential or parallel approvals Conditional routing based on document values Automatic escalation if not approved within timeframe Delegate approval authority Approval history and audit trail Template-based workflows for common scenarios External Collaboration Guest Access Collaborate with external parties securely: Invite clients, vendors, or partners as guests Limited access to specific documents or folders No access to internal team documents Time-limited guest accounts Guest activity tracked in audit logs No additional user license required Easy conversion to full member if needed Client Portals Create branded portals for external collaboration: Custom branded interface for clients Dedicated space for client documents Client can upload and download files Secure messaging with client team Client-specific reporting and analytics White-label option (remove Chaindoc branding) Multiple portals for different clients Access Control & Security Team-Level Permissions Control who can view team documents Restrict document creation to specific roles Approval requirements for sensitive documents Prevent downloading or printing IP address restrictions for team access Device restrictions (corporate devices only) Geographic restrictions (block certain countries) Authentication Options Secure team access with multiple authentication methods: Email/password with strong password policies Multi-factor authentication (MFA) required Single Sign-On (SSO) via SAML 2.0 Google Workspace / Microsoft 365 integration LDAP/Active Directory integration Biometric authentication on mobile Hardware security keys (FIDO2) Session Management Automatic logout after inactivity Force logout on password change View active sessions across devices Remote session termination Session timeout policies by role Concurrent session limits Login alerts for suspicious activity Team Analytics & Reporting Team Performance Metrics Track team productivity and document activity: Documents created per team/user Average time to signature completion Most active users and teams Document approval bottlenecks User login frequency Storage usage by team Response time to signature requests Activity Reports User activity logs (login, document access) Team collaboration statistics Document status reports (pending, completed) Failed authentication attempts Permission changes audit External user access logs Scheduled reports via email Compliance Reporting Access audit trails for regulators User certification reports Document retention compliance Security incident reports Role assignment history Data residency verification Export reports for external audits Billing & Licensing User Licenses Flexible licensing options: Per-user licensing (monthly or annual) Unlimited guest users at no extra cost Add or remove users anytime Automatic billing adjustments Volume discounts for large teams Enterprise unlimited user plans Free trial period for new users Usage Tracking Active vs. inactive user monitoring Document volume per user Storage usage by team API call usage Feature usage statistics Optimize licenses based on usage Alerts for approaching limits Integration & Automation Directory Integration Azure Active Directory sync Google Workspace directory sync Okta identity provider OneLogin SSO integration LDAP directory import Automatic user provisioning/deprovisioning Group mapping from directory Team Workflow Automation Auto-assign documents to team members Automatic folder access based on role Scheduled reports to team leads Auto-escalation of pending documents Workflow triggers based on document events Integration with project management tools Custom webhooks for team events Best Practices Team Setup Start with clear organizational structure Define roles and permissions before adding users Create team naming conventions Establish approval workflow templates Set up SSO before inviting users Document your team structure and policies Train team leads before rolling out to entire team Security Best Practices Enforce MFA for all users Regular access reviews (quarterly) Immediate deactivation of departed users Use principle of least privilege Monitor guest user access closely Regular security awareness training Test disaster recovery procedures Collaboration Efficiency Use templates for common team documents Establish clear approval chains Set SLAs for document reviews Use @mentions to notify specific users Create shared folders for ongoing projects Regular cleanup of inactive teams Leverage analytics to identify bottlenecks Onboarding New Team Members Send welcome email with getting started guide Assign mentor or buddy for first week Provide training on document workflows Grant access progressively (start limited) Schedule check-in after first week Share team guidelines and best practices Add to relevant teams and channels Troubleshooting Common Issues **User can't access team documents**: Check team membership and role permissions **Invitation not received**: Check spam folder, verify email address, resend invitation **SSO login failing**: Verify SSO configuration, check with IT admin **Permission denied error**: User may need higher role or specific document permissions **Can't add more users**: Check license limits, upgrade plan if needed **User appears twice**: Merge duplicate accounts via admin panel Getting Help Admin dashboard help center 24/7 chat support for admins Dedicated account manager (Enterprise plans) Team management video tutorials Community forum for best practices Email: admin-support@chaindoc.com Emergency security hotline for incidents

Team Management

API Integration Integrate Chaindoc into your applications with our powerful REST API and SDKs. Automate document workflows, collect signatures, and sync events in real-time. Overview Chaindoc provides a comprehensive REST API that enables you to build custom document signing workflows, automate processes, and integrate with your existing systems. The API is designed for developers with full TypeScript support and automatic retries. Document upload and management with blockchain verification Signature request creation and tracking Real-time webhooks for event notifications Embedded signing interface for seamless UX KYC/Identity verification integration Team and role management Getting Started 1. Get API Access API access is available on Business plan only Navigate to Settings → API Access in dashboard Generate Public Key (pk_) and Secret Key (sk_) Store keys securely and never commit to version control 2. Choose Integration Method Chaindoc offers three integration approaches: REST API - Direct HTTP requests for maximum flexibility Server SDK - Type-safe Node.js SDK with automatic retries (@chaindoc_io/server-sdk) Embed SDK - Frontend signing interface for web apps (@chaindoc_io/embed-sdk) 3. Quick Example Core API Concepts Authentication All API requests require authentication using API keys in the Authorization header: Public Keys (pk_) - Read-only access for frontend applications Secret Keys (sk_) - Full read/write access for backend servers Test Keys (pk_test_, sk_test_) - For staging/development Live Keys (pk_live_, sk_live_) - For production Rate Limits API endpoints have rate limits to ensure fair usage: General endpoints: 3 requests per 10 seconds Media upload: 3 requests per 10 seconds Read operations: 10 requests per 60 seconds Signature creation: 20 requests per 3 seconds Error Handling API returns standard HTTP status codes with detailed error messages: Common Integration Patterns Document Upload & Signing Flow Upload File POST /media/upload - Upload PDF, Office doc, or image Create Document POST /documents - Create document record with status='published' for blockchain verification Create Signature Request POST /signatures/requests - Add recipients and configure workflow Create Embedded Session POST /embedded/sessions - Generate session for each signer Open Signing Interface Use Embed SDK with sessionId to open signing flow in frontend Track Progress GET /signatures/requests/:id/status - Monitor signing progress Receive Webhook signature.request.completed event when all signatures collected Backend-Only Workflow For scenarios where signers don't use your interface: Bulk Document Processing Advanced Features Webhooks Receive real-time notifications for document events: KYC Integration Integrate identity verification for high-security workflows: Access Control Manage document permissions with granular access control: Best Practices Store API keys in environment variables, never in code Use test keys for development, live keys for production Implement exponential backoff for rate limit handling Verify webhook signatures to prevent replay attacks Cache API responses when appropriate Upload files before creating documents for better performance Use pagination for large datasets Monitor rate limit headers and adjust request frequency Example Integrations E-commerce Platform Automatically generate and sign purchase agreements for high-value orders. HR System Integrate with HRIS for automated employment contract signing during onboarding. CRM Integration Create signature requests directly from customer records in Salesforce, HubSpot, or custom CRM. Document Management System Add blockchain verification to existing DMS for tamper-proof audit trails. Resources API Documentation - Complete REST API reference with all endpoints SDKs - Server SDK and Embed SDK documentation with framework examples Webhooks - Real-time event notifications setup guide Quick Start - Get your first integration running in 10 minutes GitHub Examples - Sample integrations and code snippets Check API Documentation for detailed endpoint reference Review SDK documentation for type-safe integration Join GitHub community for code examples Contact [support@chaindoc.io](mailto:support@chaindoc.io) for enterprise support

API Integration

Your First Signature Complete walkthrough for sending your first document for signature with Chaindoc. Get familiar with the signing workflow in just 5 minutes. How to upload and prepare documents Adding recipients and signature fields Configuring signing workflow options Tracking signature progress Downloading signed documents with blockchain certificate Before You Start Make sure you have: A Chaindoc account (sign up for free at chaindoc.io) A document to sign (PDF, Word, or image format) Email addresses of people who need to sign Basic understanding of digital signatures Step-by-Step Guide Step 1: Upload Your Document Navigate to Documents Click the 'Documents' menu in the sidebar or dashboard Click 'New Document' Find the 'New Document' or 'Upload' button in the top right Select File Choose your document (PDF recommended, max 50MB) Add Details Enter document name, description, and tags for easy organization Use descriptive names like 'Employment Contract - John Doe - 2024' Add hashtags like #contract, #2024 for better searchability Choose 'Private' access if document contains sensitive information Step 2: Configure Document Settings Before requesting signatures, configure your document: Document Name - Clear, descriptive title Description - Brief summary of what needs to be signed Access Level - Private (only you), Team (shared with team), or Public Hashtags - Add tags like #contract, #urgent for organization Metadata - Add custom fields like client name, contract value, etc. Step 3: Create Signature Request Now that your document is uploaded, create a signature request: Click 'Request Signatures' Find the button on the document details page Add Recipients Enter email addresses of signers (one per line or comma-separated) Set Signing Order Choose 'Parallel' (all sign at once) or 'Sequential' (one after another) Set Deadline Choose when signatures must be completed by Add Message Write a personalized message to signers explaining what they're signing Parallel - All recipients can sign simultaneously (faster) Sequential - Recipients sign in specific order (useful for approval chains) Mixed - Combine both approaches for complex workflows Step 4: Configure Advanced Options Customize the signing experience: KYC Verification - Require identity verification for high-security documents Reminders - Automatic email reminders before deadline Access After Signing - Allow signers to download after completion Notifications - Email/SMS notifications for signing events Expiration - Auto-expire request after deadline Step 5: Review and Send Before sending, review all details: Recipients receive email with secure signing link They review document and apply electronic signature You receive notifications as each person signs Document is blockchain-verified upon completion All parties get copy with certificate of authenticity Step 6: Track Progress Monitor your signature request in real-time: Status Dashboard - See who has signed and who's pending Activity Timeline - View all events with timestamps Email Notifications - Get notified on each signature Reminders - System sends automatic reminders to pending signers Cancel/Modify - Cancel request or resend to specific recipients Step 7: Download Signed Document Once all signatures are collected: Completion Notification You'll receive email notification when all signatures are complete Download Document Click 'Download' to get the signed PDF with all signatures Blockchain Certificate Download the blockchain verification certificate as proof of authenticity Audit Trail Export complete signing history with timestamps and IP addresses You've completed your first signature workflow! Document is legally binding and blockchain-verified All parties have copies with certificates Complete audit trail is preserved forever What Recipients See When recipients receive your signature request: Email Notification They receive email with 'Review and Sign' button Identity Verification One-time password (OTP) sent to their email for security Document Review Full document preview with ability to zoom and navigate Sign Document Apply signature by drawing, typing, or uploading image Confirmation Receive confirmation email with copy of signed document Common Questions What if a signer doesn't receive the email? Check spam folder first. If not there, you can resend the invitation from the signature request status page. Click 'Resend' next to the recipient's name. Can I cancel a signature request? Yes! Navigate to the signature request and click 'Cancel Request'. This will notify all pending signers that the request has been cancelled. What happens after the deadline? The request automatically expires and no further signatures can be collected. You'll receive a notification and can create a new request with a new deadline if needed. Are the signatures legally binding? Yes! Chaindoc signatures comply with eIDAS (EU), ESIGN Act (US), and UETA regulations. Blockchain verification provides additional legal evidence of document authenticity. Can signers download the document before signing? By default, signers can only view documents online. You can enable 'Download Before Signing' in advanced settings if needed. Next Steps Set Up Team - Invite colleagues to collaborate on documents Create Workflows - Automate recurring signature processes Explore Templates - Save time with reusable document templates API Integration - Integrate Chaindoc into your applications Security Best Practices - Learn about compliance and data protection Use clear, specific document names Add context in the message to signers Set realistic deadlines (at least 7 days) Test the workflow with yourself first Check spam folders if signers don't receive emails Use sequential signing for approval workflows Enable reminders for better completion rates

Your First Signature

Security Best Practices Security is paramount when handling sensitive documents and blockchain transactions. This guide outlines essential security practices for deploying and maintaining Chaindoc in production environments. Authentication & Authorization Multi-Factor Authentication (MFA) Always enable MFA for all user accounts, especially administrators and users with elevated privileges. Chaindoc supports: Time-based One-Time Passwords (TOTP) via authenticator apps SMS-based verification (less secure, use only when necessary) Hardware security keys (FIDO2/WebAuthn) Biometric authentication on supported devices Strong Password Policies Enforce robust password requirements: Minimum 12 characters with complexity requirements Password expiration every 90 days for sensitive accounts Prevention of password reuse (last 10 passwords) Lockout after 5 failed login attempts Password strength meter during creation Role-Based Access Control (RBAC) Implement the principle of least privilege by assigning users only the permissions they need: Define clear roles: Viewer, Editor, Administrator, Auditor Use granular permissions for document access Regularly audit user roles and remove unnecessary access Implement time-based access for temporary contractors Separate duties for critical operations (e.g., approval workflows) Data Encryption Encryption at Rest All sensitive data must be encrypted when stored: Use AES-256 encryption for document storage Encrypt database backups with separate keys Store encryption keys in a dedicated key management service (KMS) Rotate encryption keys quarterly Enable full-disk encryption on all servers and workstations Encryption in Transit Protect data during transmission: Enforce TLS 1.3 for all connections Use strong cipher suites (disable weak ciphers) Implement certificate pinning for mobile apps Enable HSTS (HTTP Strict Transport Security) Use encrypted channels for blockchain transactions Blockchain Security Private Key Management Blockchain private keys are the most critical security asset: Never store private keys in plain text or code repositories Use hardware security modules (HSMs) for production keys Implement multi-signature wallets for high-value operations Create key backup procedures with secure offline storage Use separate keys for different environments (dev, staging, prod) Smart Contract Security If using custom smart contracts: Conduct thorough security audits before deployment Use established patterns and avoid experimental code Implement circuit breakers for emergency stops Test extensively on testnets before mainnet deployment Monitor for unusual transaction patterns Blockchain Audit Trails Leverage blockchain for immutable audit logging: Record all document state changes on-chain Hash sensitive operations for verification Implement timestamp proofs for compliance Regularly verify on-chain data integrity Archive blockchain transaction receipts API Security API Authentication Secure all API endpoints: Use OAuth 2.0 or JWT tokens for authentication Implement token expiration (15-60 minutes for access tokens) Rotate API keys regularly (every 90 days minimum) Use separate API keys for different services Never expose API keys in client-side code Rate Limiting & DDoS Protection Prevent abuse and service disruption: Implement rate limiting per API key and IP address Use exponential backoff for failed requests Deploy Web Application Firewall (WAF) Enable DDoS protection at CDN/cloud provider level Monitor for abnormal traffic patterns Input Validation & Sanitization Protect against injection attacks: Validate all input data against strict schemas Sanitize user-provided content before storage/display Use parameterized queries to prevent SQL injection Implement Content Security Policy (CSP) headers Escape output in all contexts (HTML, JavaScript, URLs) Infrastructure Security Network Segmentation Isolate critical components: Separate production, staging, and development environments Use VPCs and private subnets for sensitive services Restrict database access to application servers only Implement firewall rules with default-deny policies Use jump hosts/bastion servers for administrative access Patch Management Keep systems up to date: Apply security patches within 48 hours of release Automate dependency updates for non-breaking changes Regularly update container images and base OS Subscribe to security advisories for all used technologies Test patches in staging before production deployment Container & Orchestration Security If using containerized deployments: Use minimal base images (Alpine, Distroless) Scan images for vulnerabilities before deployment Run containers as non-root users Implement pod security policies/standards Use secrets management (not environment variables) Enable network policies to restrict pod-to-pod traffic Compliance & Auditing Regulatory Compliance Ensure compliance with relevant regulations: GDPR: Implement right to erasure and data portability HIPAA: Enable audit logging and access controls for healthcare data SOC 2: Document security controls and conduct annual audits ISO 27001: Implement information security management system Industry-specific regulations (e.g., financial services, legal) Audit Logging Maintain comprehensive logs for security and compliance: Log all authentication attempts (success and failure) Record document access, modifications, and deletions Track administrative actions and configuration changes Store logs in tamper-proof, centralized system Retain logs for minimum 1 year (or per regulatory requirements) Implement log monitoring and alerting for suspicious activity Regular Security Audits Conduct periodic security assessments: Perform quarterly vulnerability scans Conduct annual penetration testing by third parties Review access controls and user permissions monthly Audit blockchain transactions for anomalies Test backup and disaster recovery procedures quarterly Monitoring & Incident Response Security Monitoring Implement real-time security monitoring: Deploy SIEM (Security Information and Event Management) system Set up alerts for failed login attempts, privilege escalation Monitor for unusual data access patterns Track API usage anomalies Use intrusion detection/prevention systems (IDS/IPS) Incident Response Plan Prepare for security incidents: Document incident response procedures Define escalation paths and contact information Create runbooks for common security scenarios Conduct tabletop exercises quarterly Establish communication protocols for breaches Maintain forensic analysis capabilities Backup & Disaster Recovery Ensure business continuity: Implement automated daily backups Store backups in geographically distributed locations Encrypt all backup data Test restoration procedures monthly Maintain offline backups for ransomware protection Document Recovery Time Objective (RTO) and Recovery Point Objective (RPO) Development Security Secure Development Lifecycle Integrate security into development: Conduct code reviews with security focus Use static application security testing (SAST) tools Implement dependency scanning in CI/CD pipeline Require security training for all developers Never commit secrets to version control Use pre-commit hooks to prevent sensitive data leaks Third-Party Dependencies Manage external library risks: Regularly update dependencies to latest secure versions Use tools like Dependabot, Snyk, or npm audit Review security advisories for used packages Minimize number of dependencies Verify package integrity and maintainer reputation Consider vendoring critical dependencies User Education & Awareness Security is everyone's responsibility: Conduct security awareness training for all users Provide phishing and social engineering education Create clear security policies and guidelines Establish reporting mechanisms for security concerns Reward responsible disclosure of vulnerabilities Maintain up-to-date security documentation Security Checklist Use this checklist before deploying to production: ✓ MFA enabled for all user accounts ✓ Strong password policies enforced ✓ RBAC implemented with least privilege ✓ All data encrypted at rest and in transit ✓ TLS 1.3 enforced on all endpoints ✓ Private keys stored in HSM or secure vault ✓ API rate limiting configured ✓ WAF and DDoS protection enabled ✓ Input validation and sanitization implemented ✓ Network segmentation properly configured ✓ All systems patched and up to date ✓ Comprehensive audit logging enabled ✓ Security monitoring and alerting active ✓ Incident response plan documented and tested ✓ Automated backups configured and tested ✓ Security scanning in CI/CD pipeline ✓ Compliance requirements documented and met Additional Resources For more information on Chaindoc security: OWASP Top 10 Web Application Security Risks NIST Cybersecurity Framework CIS Security Benchmarks Blockchain Security Best Practices (Consensys) Cloud Security Alliance Guidelines For security issues or questions, contact our security team at security@chaindoc.com or report vulnerabilities through our responsible disclosure program.

Security Best Practices

Chaindoc REST API Reference Complete reference for integrating Chaindoc's REST API into your applications. Manage documents, signatures, blockchain verification, and embedded signing workflows. Version: 1.0.0 Base URL: https://api.chaindoc.io/api/v1 Authentication: API Key (Bearer Token) Overview Chaindoc REST API provides programmatic access to document management, blockchain verification, and digital signature functionality. The API is designed for server-to-server integration and supports both public and secret API keys. Key Features Document Management - Create, update, and manage documents with blockchain verification Digital Signatures - Request and collect digital signatures from multiple parties Blockchain Verification - Verify document authenticity on blockchain networks Embedded Sessions - Create secure sessions for frontend signing workflows Media Upload - Upload files (PDF, images, videos) for document creation KYC Integration - Share and verify identity data with Sumsub Authentication Chaindoc API uses API keys for authentication. There are two types of keys with different access levels. API Key Types Public Key (pk_) - Read-only access for frontend apps and verification Secret Key (sk_) - Full read & write access for backend servers Never expose secret keys in client-side code Use public keys for read-only operations in browsers Rotate keys regularly for security Store keys in environment variables Obtaining API Keys Subscribe to Business Plan Only Business plan users can create API keys Navigate to API Access Go to Settings → API Access in your dashboard Create API Key Click Create API Key button Store Securely Store the secret key securely (shown only once) Using API Keys Include your API key in the Authorization header with Bearer authentication: Rate Limiting API endpoints are rate-limited to prevent abuse. Rate limits vary by endpoint type. General endpoints: 3 requests per 10 seconds Media upload: 3 requests per 10 seconds OTP verification: 5 requests per 60 seconds Read operations: 10 requests per 60 seconds Signature creation: 20 requests per 3 seconds When rate limit is exceeded, you'll receive a 429 Too Many Requests response. Rate limit headers are included in responses: Error Handling HTTP Status Codes 200 - Success 201 - Resource created successfully 400 - Bad request (validation error) 401 - Unauthorized (invalid or missing API key) 403 - Forbidden (insufficient permissions) 404 - Resource not found 429 - Too many requests (rate limit exceeded) 500 - Internal server error Error Response Format General API Get API Key Info Get information about the current API key. Health Check Verify API connectivity and key validity. Documents API Create Document Create a new document with blockchain verification. When status is set to 'published', the document is automatically verified on blockchain. Update Document Update a document by creating a new version. Previous versions are preserved for audit trail. Update Document Access Rights Update document access control settings. Verify Document Verify document authenticity using blockchain. Returns verification status with transaction hash and chain ID. Get Verification Status Get blockchain verification status for a document version. Signatures API Create Signature Request Create a signature request for one or more recipients. Enable embedded flow for frontend integration. Get Signature Request Status Check the status of a signature request and see which signers have completed signing. Sign Document Sign a document (if API key owner is a signatory). Get User Signatures Get all signatures for the authenticated user. Get Signature Requests Get all signature requests for the authenticated user with pagination support. Media Upload API Upload files for use in document creation. Supports PDF, images, and videos. Maximum 10 files per request. Documents: PDF, DOC, DOCX, XLS, XLSX, PPT, PPTX, TXT Images: JPG, JPEG, PNG, GIF, WEBP, SVG Videos: MP4, AVI, MOV, WMV KYC API Share KYC Data Share KYC (Know Your Customer) data with recipients for identity verification. Embedded Sessions API Create embedded sessions for document signing in your frontend application. Sessions are valid for 10 minutes. 1. Create embedded session (OTP sent to email) 2. User verifies OTP on frontend 3. Frontend receives JWT token 4. Use token to call embedded endpoints

API Documentation

Chaindoc SDKs Official SDKs for seamless Chaindoc integration. Full TypeScript support, zero dependencies, and framework-agnostic design for both backend and frontend applications. Available SDKs Server SDK (@chaindoc_io/server-sdk) - Backend integration for Node.js 18+ Embed SDK (@chaindoc_io/embed-sdk) - Frontend signing interface for web applications Python SDK - Coming soon PHP SDK - Coming soon Server SDK The Server SDK provides a type-safe Node.js interface for the Chaindoc API. Use it to manage documents, create signature requests, handle file uploads, and integrate blockchain verification into your backend. Installation Node.js 18 or higher (uses native fetch API) Secret API key (sk_live_* or sk_test_*) Quick Start Express.js Integration Next.js API Routes Error Handling Always wrap API calls in try-catch blocks and handle ChaindocError specifically: Embed SDK The Embed SDK enables seamless integration of document signing functionality into web applications. It manages an iframe-based signing flow with secure communication between your application and Chaindoc. Installation Zero runtime dependencies Full TypeScript support Framework agnostic (React, Vue, Angular, Svelte) Lightweight: < 10KB gzipped Secure: origin validation and iframe sandboxing Basic Usage React Integration Vue 3 Integration Inline Mode Instead of a modal, embed the signing interface directly into your page: Theming Customize the appearance with light or dark themes: Complete Workflow Example Here's a complete end-to-end example combining Server SDK and Embed SDK: Backend: Upload Document Use Server SDK to upload file and create document Backend: Create Signature Request Create signature request with embedded flow enabled Backend: Generate Session Create embedded session for each signer Frontend: Initialize Embed SDK Initialize SDK with public key Frontend: Open Signing Flow Open signing interface with session ID Frontend: Handle Success Process signed document and update UI Best Practices Initialize SDK once per page/component lifecycle Always destroy SDK instance on component unmount Handle all callback events (onSuccess, onError, onCancel) Store API keys in environment variables Use TypeScript for better type safety Implement proper error handling with ChaindocError Test with sandbox keys before production deployment Environment Configuration Check the Webhooks documentation for real-time notifications Read the REST API reference for complete endpoint documentation Explore framework-specific examples in the GitHub repository

SDKs

Chaindoc Webhooks Receive real-time notifications when events occur in your Chaindoc account. Webhooks push event data to your server instantly, eliminating the need for polling. Business Plan subscription (only Business plan users can configure webhooks) HTTPS endpoint on your server Publicly accessible URL (webhooks cannot be sent to localhost) Overview Chaindoc Webhooks allow your application to receive real-time notifications when events occur in your account. Instead of polling the API, webhooks push event data to your server as soon as an action happens. Key Features Real-time Notifications - Instant event delivery to your server Automatic Retries - Up to 3 retry attempts with exponential backoff Signature Verification - HMAC SHA256 for payload authenticity Event Filtering - Receive only the events you care about Error Tracking - Monitor webhook delivery status and failures Use Cases Send email notifications when documents are signed Trigger workflows when documents are verified on blockchain Update your database when signature requests are created Sync document status with external systems Audit trail and compliance logging Setup Step 1: Create API Key Navigate to Settings → API Access in your Chaindoc dashboard and create an API key with webhook configuration enabled. Step 2: Configure Webhook URL Use the API to configure your webhook endpoint: Step 3: Implement Webhook Endpoint Create an endpoint on your server to receive webhook events. Here are examples in different languages: Event Types Chaindoc sends webhooks for the following events: document.created Triggered when a new document is created via API. document.verified Triggered when a document is successfully verified on blockchain. document.signed Triggered when all required signatures are collected. signature.request.created Triggered when a new signature request is created. signature.request.completed Triggered when all signers complete their signatures. signature.request.rejected Triggered when a signer rejects the signature request. Security Signature Verification Chaindoc signs all webhook payloads using HMAC SHA256. Always verify signatures to ensure authenticity and prevent replay attacks. Always use timing-safe comparison functions Never skip signature verification in production Keep your webhook secret secure Rotate secrets periodically Use HTTPS endpoints only How Signature Verification Works Chaindoc Creates Signature Chaindoc creates HMAC signature using your webhook secret Signature Sent in Header Signature is sent in X-Webhook-Signature header Your Server Verifies Your server recalculates signature and compares using timing-safe function Retry Logic Chaindoc automatically retries failed webhook deliveries with exponential backoff. 1st retry: After 1 minute 2nd retry: After 5 minutes (total: 6 minutes) 3rd retry: After 15 minutes (total: 21 minutes) Your endpoint returns HTTP status code 200-299 Your endpoint responds within 30 seconds No network errors occur during delivery Testing Webhooks Local Development Use tools like ngrok to expose your local server for webhook testing: Manual Testing Test your webhook endpoint with a sample payload: Best Practices Always verify webhook signatures before processing Respond quickly (under 30 seconds) to avoid timeouts Process webhooks asynchronously in a queue Implement idempotency to handle duplicate events Log all webhook events for debugging and audit Monitor webhook delivery failures in your dashboard Use HTTPS endpoints for security Handle all event types gracefully (ignore unknown events) Complete Example Here's a production-ready webhook handler with database integration: Configure your webhook URL in the Chaindoc dashboard Test with ngrok during development Monitor webhook delivery in your logs Set up alerts for failed deliveries

Webhooks

Changelog Stay informed about Chaindoc platform updates, new features, improvements, and bug fixes. Track every release to keep your integration up to date. Major releases: Quarterly with breaking changes and new features Minor releases: Monthly with backwards-compatible improvements Patch releases: Weekly with bug fixes and performance improvements Security updates: As needed with immediate deployment Version 1.0.0 - December 2025 Official v1.0.0 release with stable API Production-ready SDKs with full TypeScript support Complete documentation and developer guides Enterprise-grade security and compliance New Features 🎉 Server SDK (@chaindoc_io/server-sdk) - Official Node.js SDK with automatic retries 🎉 Embed SDK (@chaindoc_io/embed-sdk) - Frontend signing interface for React, Vue, Angular 🎉 Webhooks - Real-time event notifications with HMAC signature verification 🎉 Embedded Signing Flow - Seamless signing experience within your application 🎉 KYC Integration - Identity verification with Sumsub 🎉 Access Control - Granular permissions with role-based and email-based access ✨ Multi-chain Support - Ethereum, Polygon, BSC, Arbitrum blockchain verification ✨ Batch Operations - Upload and process multiple documents efficiently ✨ Advanced Search - Full-text search with hashtags and metadata filtering API Improvements Rate limiting with detailed headers (X-RateLimit-*) Improved error responses with field-level validation details Pagination support for all list endpoints Health check endpoint for monitoring API key management with usage statistics SDK Features Full TypeScript definitions with IntelliSense support Automatic retry logic with exponential backoff Zero runtime dependencies for Embed SDK Framework-agnostic design (React, Vue, Angular, Svelte) Debug mode for development troubleshooting Security Enhancements HMAC SHA256 webhook signature verification API key rotation with zero downtime IP whitelisting for API access Two-factor authentication (2FA) for dashboard SOC 2 Type II compliance certification Documentation Complete REST API reference with all endpoints SDK documentation with framework examples Webhooks setup guide with code samples Integration patterns and best practices Troubleshooting guides and FAQs Upcoming Features Python SDK for backend integration PHP SDK for legacy system integration Mobile SDKs (iOS and Android) Advanced template system Bulk signature requests Custom branding for signing interface Advanced analytics dashboard Watch our GitHub repository for releases Subscribe to developer newsletter Join Discord community for announcements

Changelog

Stay informed about Chaindoc platform updates, new features, improvements, and bug fixes. Track every release to keep your integration up to date.