Manage, Send and Sign Contracts in One Place
Draft contracts from templates, send them for signature with SMS or email identity verification, and track every signature and renewal. Signed copies are delivered automatically.
Start Today
EVERYTHING IN ONE PLACE
Everything You Need to Stay Organized
Stay on top of every contract, signature, and renewal, all from one dashboard.
Every contract lives in one table you can filter and search, so nothing gets lost in email threads or scattered drives.
Party details, categories, and related documents stay connected automatically, giving you the full context behind every agreement.
- Party details auto-populated from user profiles
- Categorize as core, amendment, supplement, or addendum
- Filter by direction, status, category, date, or party
- Download, reuse, edit, or delete in a click
-
Centralized dashboard
View every contract in one table, filtered by direction, status, category, dates, and parties. Never lose track of an agreement again.
-
Signature tracking
Mark which parties need to sign, follow signature status, and see at a glance which contracts are still waiting.
-
Contract relationships
Link amendments, supplements, and addenda to their parent contract, keeping a clear chain of related documents.
-
Important dates
Track issue, end, renewal, and signing dates, so a critical deadline or renewal never slips past you.
SOUND FAMILIAR?
Contract Chaos Costing You Time?
The email, print, scan, and rescan loop is still how most businesses handle contracts: delays, version confusion, and no reliable way to verify who actually signed. Here is what that costs you, and how Enlivy changes it.
- The problem
Lost in email chains
Searching through endless emails to find that one contract version, never sure which is the final signed copy.
Every contract lives in one searchable dashboard, with the signed copy always a click away.
- The problem
Signature bottlenecks
Waiting days or weeks to track down who needs to sign what, while critical deals sit and wait.
Send for signature with clear per-party rules and live status. Signed in hours, not days.
- The problem
Missing renewal dates
Contracts expire without warning because renewal dates live in scattered spreadsheets, or nowhere at all.
Issue, end, and renewal dates are tracked automatically, so nothing expires by surprise.
- The problem
No clear audit trail
When a question comes up, there is no reliable way to trace a contract's history, parties, or amendments.
Every change, party, and amendment is linked and logged in one complete history.
BUILD OR IMPORT
Two Ways to Manage Contracts
Build contracts from scratch or bring in documents from anywhere, with the same control over both.
Write professional contracts directly in Enlivy using modular chapters, a Markdown editor, and reusable templates.
Or bring in contracts created outside Enlivy, PDFs or documents from any source, for centralized tracking, signing, and storage.
- Assign senders and receivers from your team or a third party
- Link amendments and supplements to a parent contract
- Generate professional PDFs automatically
- Set direction: sent by you or received from others
-
Build from scratch
Write contracts in-platform with modular chapters, a Markdown editor, reusable templates, and a signature disclaimer on every document.
-
Import from anywhere
Upload PDFs or documents from any source and bring them under centralized tracking, signing, and storage.
-
Automatic numbering
Every contract gets a unique number from your own series, with custom prefixes you control.
-
Signature rules per party
Set who has to sign and the identity verification each party needs before a contract goes out.
-
Draft to fully signed
Track every contract from draft through to fully signed, with clear signature status at each stage.
-
Instant search and retrieval
Store all contract metadata in one place and find any document in seconds.
THE ENLIVY ADVANTAGE
Stop Juggling Tools. Use One System.
| Requirement | Enlivy Contracts | Traditional Methods |
|---|---|---|
| Contract Creation | Built-in editor with templates | Separate word processor needed |
| Document Storage | Centralized dashboard with search | Scattered across email and drives |
| Signature Tracking | Automatic status updates per party | Manual follow-ups via email |
| Version Control | Clear parent-child relationships | File names like "final_v3_FINAL" |
| Renewal Reminders | Built-in date tracking | Calendar entries or nothing |
| Party Information | Auto-populated from user profiles | Manually typed each time |
| Search & Filter | Filter by status, date, party, category | Search file names and hope |
| Audit Trail | Complete history in one place | Pieced together from emails |
CONFIGURE SIGNING RULES
You Decide How Each Party Verifies
Before sending, choose who needs to sign and the identity verification each signer needs: email, phone (SMS), or both. Match the level to the contract's sensitivity.
- Email verification
A unique 6-digit code is sent to the signer's registered email and expires in 10 minutes. Good for standard and internal agreements.
- Phone verification
A 6-digit code is sent via SMS to the signer's registered phone number, adding a physical device factor for higher-security requirements.
- Combined verification
The signer verifies via email first, then via phone. Both must pass before the contract opens. Use it for high-value or legally sensitive agreements.
How Signing Works
-
Signers receive their link
Each signer gets a personalized email with an individual signing link. No Enlivy account needed. No software to install. Signers click, verify their identity using the configured method, and proceed.
-
Read, then sign
After verifying identity, the signer reads the full contract. A reading progress bar is displayed at the bottom of the screen; the Sign button only activates once the contract has been fully read. The signer then draws their signature and checks the box: “I understand this is a legally binding agreement.” Only when both conditions are met does Sign Contract become active.
-
Signed copy delivered automatically
Once signed, the signer immediately receives an email with the signed document. Once all parties have signed, everyone receives the final version with all signatures included. The contract status and final document are automatically updated in Enlivy, no manual filing required.
Commercial Operations Platform
Ready to Take Control of Your Contracts?
Join teams who've simplified their contract management with Enlivy.
Free to start · No credit card required · EU e-invoicing built in
Get Started in Minutes
Everything you need to organize contracts, all in one quick flow.
-
Access Contracts Dashboard
Navigate to Contracts from your left menu. You’ll see all existing contracts in a clean, organized table view.
-
Choose Your Method
Click “Add Contract +” and select either Create Using Enlivy for new contracts, or Upload External for documents created outside the platform.
-
Fill in Details
Enter contract information, select parties, set dates, and add content using our intuitive tabs: Information, Parties, General, Content Introduction, and Chapter Details.
-
Track and Manage
Once added, your contract appears in the dashboard. Monitor signature status, track deadlines, edit details, or reuse as templates for future contracts.
Commercial Operations Platform
Ready to Take Control of Your Contracts?
Join teams who've simplified their contract management with Enlivy.
Free to start · No credit card required · EU e-invoicing built in
API Reference
Contract Management from the API
Draft, send, sign, and track contracts end-to-end, without your users ever leaving your product. The Contracts API covers the whole lifecycle: assemble a contract from chapters and parties, move it through your own status pipeline, open a legally-binding signing session per signer, and pull the signed document plus its tamper-evident audit evidence back out.
Everything is organized around four resources: contracts (the document, its chapters and its parties), contract statuses (your configurable pipeline stages), signing sessions (one per party, with email / SMS verification), and the audit trail (delivery logs and signing evidence). The examples below walk the entire flow.
Query your contracts with pagination, rich filtering, and full-text search. Filter by status, sender, receiver, direction (inbound / outbound), category (core, amendment, addenda, supplement), source (internal / uploaded), locale, parent contract, or any of the date ranges (issued_at, ends_at, created_at, updated_at). Expand related records inline.
const organizationId = "your_org_id";
const token = "YOUR_TOKEN_HERE";
fetch(
`https://api.enlivy.com/organizations/${organizationId}/contracts?page=1&limit=20` +
// filters are optional and combinable
`&direction=outbound&category=core` +
// pass a q=... param instead of ids to run a full-text search
`&include=contract_status,sender_user,receiver_user,contract_parties` +
`&include_meta=navigation`,
{
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
}
}
); Retrieve a single contract with everything attached: its chapters, its parties, the current pipeline status, the linked file, and the sender / receiver.
const organizationId = "your_org_id";
const contractId = "your_contract_id";
const token = "YOUR_TOKEN_HERE";
fetch(
`https://api.enlivy.com/organizations/${organizationId}/contracts/${contractId}` +
// available includes: organization, parent_contract, sender_user, receiver_user,
// file, contract_status, contract_chapters, contract_parties, contract_prefix
`?include=contract_chapters,contract_parties,contract_status`,
{
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
}
}
); Build a contract in one call: its metadata, its body as ordered chapters, and its parties. A party can be an individual or an organization, and each carries how it should be referenced in the document and whether its signature is required.
const organizationId = "your_org_id";
const token = "YOUR_TOKEN_HERE";
fetch(`https://api.enlivy.com/organizations/${organizationId}/contracts`, {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
// core | amendment | addenda | supplement.
// amendment/addenda/supplement REQUIRE organization_contract_id -> a "core" parent contract.
category: "core",
// internal -> auto-numbered from a prefix (organization_contract_prefix_id required below)
// uploaded -> you supply `number`, and may set `signed_by_all_parties_at`
source: "internal",
direction: "outbound", // outbound | inbound
organization_sender_user_id: "org_user_sender_id",
organization_receiver_user_id: "org_user_receiver_id",
organization_contract_status_id: "contract_status_id",
// required only for internal + core; omit it for any other source/category
organization_contract_prefix_id: "contract_prefix_id",
title: "Master Services Agreement",
sub_title: "2026 Engagement",
locale: "en",
issued_at: "2026-07-03 09:00:00",
ends_at: "2027-07-03 09:00:00",
content_introduction: "This agreement is entered into between the parties below.",
content_signature_disclaimer: "By signing, each party agrees to the terms above.",
chapters: [
{ title: "Scope of Work", content: "<p>The Provider will deliver…</p>", order: 1 },
{ title: "Payment Terms", content: "<p>Fees are due within 14 days…</p>", order: 2 }
],
parties: [
{
// party_type, party_country_code, first_name, last_name are required on every party
party_type: "organization", // organization | individual
party_country_code: "RO",
// organization parties additionally REQUIRE organization_name + organization_type
organization_name: "Acme Studio SRL",
organization_type: "srl", // value comes from reference data
first_name: "Jane",
last_name: "Doe",
role_in_organization: "Administrator",
referenced_as_within_document: "the Provider",
appears_as_party: true,
is_signature_required: true,
contact_email_address: "jane@acme.example",
order: 0
// country-specific `information` (person) and `organization_information` (company)
// JSON blocks are also accepted; their shape is validated against the country schema.
},
{
party_type: "individual",
party_country_code: "RO",
first_name: "John",
last_name: "Smith",
referenced_as_within_document: "the Client",
appears_as_party: true,
is_signature_required: true,
contact_email_address: "john@example.com",
order: 1
}
]
})
}); Update a contract’s metadata, move it to another status, adjust its chapters, or refine its parties. Send only what you want to change.
const organizationId = "your_org_id";
const contractId = "your_contract_id";
const token = "YOUR_TOKEN_HERE";
fetch(`https://api.enlivy.com/organizations/${organizationId}/contracts/${contractId}`, {
method: "PUT",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
// partial update, only the fields you send are touched
organization_contract_status_id: "next_status_id",
sub_title: "2026 Engagement (revised)",
ends_at: "2027-12-31 23:59:59"
})
}); Render and download the contract as a PDF, the same document your counterparties see.
const organizationId = "your_org_id";
const contractId = "your_contract_id";
const token = "YOUR_TOKEN_HERE";
// returns a file stream, read it as a blob, not JSON
const pdf = await fetch(
`https://api.enlivy.com/organizations/${organizationId}/contracts/${contractId}/download`,
{
method: "GET",
headers: { Authorization: `Bearer ${token}` }
}
).then((r) => r.blob()); Soft-delete a contract. It can be restored later.
const organizationId = "your_org_id";
const contractId = "your_contract_id";
const token = "YOUR_TOKEN_HERE";
// soft delete, restore via POST /contracts/restore/{contractId}
fetch(`https://api.enlivy.com/organizations/${organizationId}/contracts/${contractId}`, {
method: "DELETE",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
}
}); Contracts move through your pipeline, not a fixed one. Each status maps to a lifecycle state (draft, action_required, accepted, breach, or terminated), carries localized labels, a color, and an order, and applies to inbound, outbound, or any direction. List them to build a board or drive automation.
const organizationId = "your_org_id";
const token = "YOUR_TOKEN_HERE";
fetch(
`https://api.enlivy.com/organizations/${organizationId}/contract-statuses?page=1&limit=50`,
{
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
}
}
); Define a new pipeline stage. Labels and descriptions are per-locale language maps, contract_state ties the stage to a lifecycle state, and you can auto-advance to another status once an action succeeds.
const organizationId = "your_org_id";
const token = "YOUR_TOKEN_HERE";
fetch(`https://api.enlivy.com/organizations/${organizationId}/contract-statuses`, {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
// per-locale maps, not plain strings
title_lang_map: { en: "Awaiting Signature", ro: "În așteptarea semnării" },
description_lang_map: {
en: "Sent to all parties for signing.",
ro: "Trimis către toate părțile pentru semnare."
},
contract_state: "action_required", // draft | action_required | accepted | breach | terminated
direction: "any", // inbound | outbound | any
// order is unique per organization, pick a free slot,
// or reorder existing stages via PUT /contract-statuses/reorder
order: 3,
rgba_color_code: "rgba(59, 130, 246, 1)"
})
}); A signing session is created per party that needs to sign. Choose the accepted signature types (draw, checkbox, classic file, electronic file), which confirmations are required (email, phone, legally-binding acknowledgement), and an expiry. With signature_source user_flow, Enlivy hosts the guided signer experience and returns a tokenized signing URL.
const organizationId = "your_org_id";
const token = "YOUR_TOKEN_HERE";
fetch(`https://api.enlivy.com/organizations/${organizationId}/contract-signatures`, {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
organization_contract_id: "contract_id",
// one active session per party, organization_contract_party_id is unique
organization_contract_party_id: "party_id",
// user_flow -> Enlivy hosts the signer experience (get the link via sign_session_url)
// admin_panel -> you record the signature yourself and may send is_signed / signature_drawing / signed_contract
signature_source: "user_flow",
sign_session_signature_types: ["draw", "checkbox"], // draw | checkbox | file_classic | file_electronic
sign_session_required_confirmations: ["email", "legally_binding"], // email | phone | legally_binding
expires_at: "2026-07-17 23:59:59"
})
}); Deliver the signing session to the party by email or SMS, with an optional custom message. Every send is recorded in the notification log for audit.
const organizationId = "your_org_id";
const signatureId = "your_signature_id";
const token = "YOUR_TOKEN_HERE";
fetch(
`https://api.enlivy.com/organizations/${organizationId}/contract-signatures/${signatureId}/send`,
{
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
method: "email", // email | sms
message: "Please review and sign the agreement by Friday."
})
}
); Poll a session for its status, whether it’s signed, its expiry, and which evidence artifacts exist. Include sign_session_url to get the hosted signing link to hand to the signer.
const organizationId = "your_org_id";
const signatureId = "your_signature_id";
const token = "YOUR_TOKEN_HERE";
fetch(
`https://api.enlivy.com/organizations/${organizationId}/contract-signatures/${signatureId}` +
// sign_session_url returns the hosted link to give to the signer.
// status is one of: pending | sent | completed | expired | void
`?include=sign_session_url,organization_contract`,
{
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
}
}
); List every signing session, optionally scoped to a single contract, the quickest way to see who has signed and who is still pending across all parties.
const organizationId = "your_org_id";
const token = "YOUR_TOKEN_HERE";
fetch(
`https://api.enlivy.com/organizations/${organizationId}/contract-signatures` +
// omit organization_contract_id to list sessions across every contract
`?organization_contract_id=contract_id&include=sign_session_url`,
{
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
"Content-Type": "application/json"
}
}
); Pull the tamper-evident evidence package (authentication, consent, and signature biometrics captured during signing) for compliance and dispute handling.
const organizationId = "your_org_id";
const contractId = "your_contract_id";
const token = "YOUR_TOKEN_HERE";
// also available per session: /contract-signatures/{signatureId}/download-evidence
const evidence = await fetch(
`https://api.enlivy.com/organizations/${organizationId}/contracts/${contractId}/download-evidence`,
{
method: "GET",
headers: { Authorization: `Bearer ${token}` }
}
).then((r) => r.blob()); Works together with
- Proposals Turn a won opportunity into a professional, itemized proposal your client can review, accept, and pay in one flow, all connected to your products, prospects, and invoices.
- Prospects Track every opportunity from first contact to paid invoice, with a complete activity history, automatic status-driven emails, and client collaboration built in.
- Users Easily customize roles and permissions in Enlivy for clients, partners, accountants, and administrators, ensuring secure and efficient access with full audit trails for compliance.
- Customer Portal A branded, self-service portal on your own domain where clients accept proposals, pay invoices, manage subscriptions, sign contracts, and submit reports themselves. Every action syncs back to Enlivy in real time.
- MCP Connect Enlivy to Claude, ChatGPT, Cursor, or any AI assistant through MCP. Ask about your invoices, contracts, and pipeline, and get real work done, safely scoped to exactly what your own account can already do.