Where do I start with Chaindoc?

Head to the Quick Start guide. It walks you through creating an account, uploading your first document, and sending it for signature. Takes about five minutes if you already have a document ready.

Is there an API reference?

Yes. The API reference covers every endpoint, including authentication, document upload, signer management, and webhook configuration. Each endpoint includes request and response examples you can test in the sandbox.

What SDKs are available for Chaindoc?

Chaindoc has SDKs for JavaScript/TypeScript, Python, and Go. The SDKs and libraries page has installation instructions and code samples. If your language isn't listed, the REST API works with any HTTP client.

How do webhooks work in Chaindoc?

Chaindoc sends POST requests to your endpoint when events happen: document signed, viewed, expired, and so on. The webhooks guide shows how to configure endpoints, verify signatures, and handle retries.

Do I need an account to use the Chaindoc sandbox?

Yes, but it's free. Sign up at chaindoc.io and you'll get sandbox access automatically. No credit card needed. The sandbox mirrors production, so anything you build there will work the same way when you switch.

Where can I find Chaindoc code examples?

Every docs page has inline code snippets. For full working examples, the guides section includes end-to-end signing flows, bulk operations, and template-based workflows with copy-paste code.

Introduction to Chaindoc

Chaindoc is a blockchain-powered tool for electronic signatures and document management. You get legally binding e-signatures, immutable verification, and a full API to build on top of.

What is Chaindoc?

Chaindoc handles three things: documents, signatures, and team collaboration. Every document you publish gets verified on a blockchain network, which means nobody can tamper with it after the fact. That's the part most signing tools skip.

It's built for developers who want to embed signing into their own apps, but it also works out of the box through the web interface. You don't need to write code to send your first signature request.

Why does blockchain matter here?

A signed PDF can be edited. A blockchain record can't. When you verify a document on Chaindoc, its hash gets written to Ethereum, Polygon, BSC, or Arbitrum. Anyone can check that hash years later and confirm the document hasn't changed. That's what makes it different from a standard e-signature.

What you can do with Chaindoc

Blockchain verification

Every published document gets a hash written to a blockchain network automatically. You don't need to configure anything. The verification works across Ethereum, Polygon, BSC, and Arbitrum, so you can pick the chain that fits your cost and speed requirements.

Electronic signatures

Chaindoc supports simple, advanced, and qualified signatures that comply with eIDAS, the ESIGN Act, and UETA. You can set up multi-party signing workflows with sequential or parallel signing orders, deadlines, and automatic reminders.

Here's the thing: most teams don't need qualified signatures. Simple e-signatures cover 90% of business contracts. Check the signatures docs to figure out which type fits your use case.

Document management

Version control with a full audit trail for every change
PDF, Office files, images, and video uploads
Access control: private, public, team, or restricted
Metadata, hashtags, and full-text search to find things fast

If you're coming from a shared drive or basic file storage, the biggest difference is the audit trail. Every view, edit, and signature gets logged. You can read more about how this works in the document management guide.

Developer tools

Chaindoc has a REST API and TypeScript SDKs for both backend (Node.js) and frontend (React, Vue, Angular). You can also drop in the embedded signing component, so your users sign documents without leaving your app.

Full REST API with auth, rate limiting, and sandbox mode
Server SDK for Node.js and an Embed SDK for web frontends
Webhooks for real-time event notifications
Sandbox environment where you can test without affecting production

Team collaboration

You can invite team members with role-based access: Owner, Admin, Member, or Viewer. Each role controls what someone can see, edit, and sign. Activity logs track everything, which matters when you need to prove who approved what.

For teams that need identity verification, Chaindoc integrates with Sumsub for KYC checks. Take a look at the team management page for setup details.

How the signing flow works

The typical flow from upload to signed document takes six steps. Most of it is automated once you set up the request.

1Upload your documentUpload a PDF, Office file, image, or video through the web interface or via the API. The file gets stored and assigned a unique ID.

2Create a signature requestAdd recipients, set a signing order (sequential or parallel), pick a deadline, and write a custom message if you want. This takes about 30 seconds in the UI.

3Signers get notifiedRecipients receive an email with a secure signing link. If you're using the Embed SDK, they'll see the signing interface right inside your app instead.

4Signers review and signEach signer authenticates via OTP, reviews the document, and applies their electronic signature. The whole process takes under a minute for most documents.

5Blockchain verificationOnce all parties sign, the document hash gets written to the blockchain automatically. This creates an immutable proof of the document's state at signing time.

6Everyone gets the signed copyAll parties receive the final document with a blockchain verification certificate attached. You can verify authenticity anytime using the certificate.

Common use cases

Chaindoc works across industries, but here's where teams get the most value:

Legal and compliance — contracts, NDAs, employment agreements. The blockchain audit trail satisfies most regulatory requirements without extra paperwork.
Real estate — property agreements and lease contracts where you need an immutable record that holds up in disputes.
Financial services — loan agreements, investment documents, and compliance forms that need to meet regulatory standards.
Healthcare — patient consent forms and medical records under HIPAA-compliant document handling.
Enterprise — internal approvals, HR documents, vendor agreements. Teams that process hundreds of contracts a month save the most time by automating with the API.

Architecture overview

Chaindoc combines standard cloud infrastructure with a blockchain layer. You don't need to understand the full stack to use the API, but it helps to know what's running under the hood:

Web app built on React and Next.js
Node.js REST API with auth, rate limiting, and versioning
PostgreSQL for structured data, S3 for file storage
Smart contracts on Ethereum, Polygon, BSC, and Arbitrum for document verification
Event-driven message queue that powers webhooks and notifications
Global CDN for fast document delivery

Security and compliance

Security isn't an add-on here. It's baked into how documents get stored, transmitted, and verified.

What's covered

AES-256 encryption for data at rest and in transit SOC 2 Type II certified infrastructure Compliant with GDPR, eIDAS, the ESIGN Act, and UETA Regular third-party security audits and penetration testing Two-factor authentication and IP whitelisting for API keys

If you're handling sensitive documents, check the security best practices guide for recommendations on access control, encryption settings, and compliance configurations.

Where to go next

Pick the path that matches what you're trying to do:

Quick Start — send your first document for signing in under 10 minutes
Installation — set up the SDKs in your dev environment
API documentation — full REST API reference with examples
SDKs — Node.js Server SDK and Embed SDK for web apps

First time here?

Start with the Quick Start guide. It walks you through the full signing flow in about 10 minutes, no SDK setup required. If you already know what you're building, jump straight to the API docs.

Documentation