Contracts
Draft contracts and get them signed online
Write a contract, or let Enlivy draft it from your package's template when a client accepts your proposal. You send it, and your client signs online with an optional email or SMS code.
Send your first contractFree account, no card needed.
CONTRACT OVERVIEW
See every contract and who still has to sign
One list holds every contract, its signers and its dates.
Contracts with your clients and with your suppliers sit in one list you can search and filter.
Each contract keeps its parties, its category and the documents linked to it.
- Party details filled in from each party's profile
- Mark each contract as core, amendment, supplement or addendum
- Filter by direction, status, category, date or party
- Download, edit or delete any contract
-
One contract list
Contracts with your clients and with your suppliers sit in the same list.
-
Signature tracking
Choose which parties must sign, then see which contracts still wait for a signature.
-
Contract relationships
Link amendments, supplements and addenda to the main contract they change.
-
Important dates
Keep issue, end, renewal and signing dates on each contract, and filter for what is coming up.
Which version did they sign?
Many businesses still email, print, sign and scan their contracts. It is slow, versions get mixed up, and nobody can show who signed.
-
Lost in email threads
Without Enlivy: You search old emails for the contract and are never sure which copy is the signed one.
With Enlivy: Every contract sits in one searchable list, with the signed copy one click away.
-
Waiting for signatures
Without Enlivy: Days pass while you work out who still has to sign, and the deal waits.
With Enlivy: You send each signer a link and see who has signed and who has not.
-
Missed renewal dates
Without Enlivy: A contract ends without anyone noticing, because its renewal date sits in a spreadsheet, or nowhere.
With Enlivy: Issue, end and renewal dates sit on every contract, so you can filter for what is coming up.
-
No proof of who signed
Without Enlivy: When a question comes up, you cannot trace a contract's history, its parties or its amendments.
With Enlivy: Amendments stay linked to the main contract. For each signature, Enlivy keeps a fingerprint of the exact text signed, the code check passed and how far the signer read.
BUILD OR IMPORT
Write contracts in Enlivy, or upload your own
Both kinds go into the same list and the same signing steps.
Write a contract in Enlivy, or add a contract template to a package. When a client accepts a proposal for that package, Enlivy drafts the contract with the parties, the items and the payment terms. Enlivy does not send it: you check the draft and send the signing request.
You can also upload contracts made elsewhere, as a PDF or a document, then track them and send them for signing in the same way.
- Pick the sender and the receiver, from your team or another party
- Link amendments and supplements to the main contract
- Download each contract as a PDF
- Set the direction: sent by you or received from others
-
Write it in Enlivy
Write contracts in chapters, with headings, lists and bold text, and your own note above the signature lines.
-
Upload your own
Upload contracts made elsewhere, as a PDF or a document. Then send them for signing and keep them with the rest.
-
Your numbering
Each contract gets the next number of your own series, with the prefix you choose.
-
Signature rules per party
Set who has to sign and how each signer proves who they are, before the contract goes out.
-
Draft to fully signed
Follow each contract from draft to fully signed. When the first party signs, the text locks, so every signer signs the same text.
-
Search and filters
Search and filter contracts by party, status, category or date.
THE ENLIVY ADVANTAGE
Contracts in Enlivy, compared with documents and email
| Requirement | Enlivy Contracts | Documents and email |
|---|---|---|
| Contract creation | Editor and contract templates | A separate word processor |
| Document storage | One contract list with search | Scattered across email and drives |
| Signature tracking | Status for each signer | Follow-up emails |
| Version control | Amendments linked to the main contract | File names like "final_v3_FINAL" |
| Renewal dates | Stored on each contract, filterable | Calendar entries, or nothing |
| Party information | Filled in from each party's profile | Typed again each time |
| Search and filter | Filter by status, date, party, category | Search file names and hope |
| Audit trail | Signing evidence kept for each signature | Pieced together from emails |
SIGNING RULES
Choose how each signer proves who they are
Before you send a contract, choose who signs and whether each signer confirms with a code by email, by SMS, or both. Invitations and codes by SMS go through your own Twilio account. Enlivy's signature is a simple electronic signature, the basic level under eIDAS, the EU rules on electronic signatures. Where the law requires a qualified signature, use a qualified provider.
- Email verification Nobody can sign until they show they can open that mailbox.
A 6-digit code goes to the signer's email and expires after 10 minutes. Good for standard and internal agreements.
- Phone verification
A 6-digit code is texted to the signer's phone and expires after 5 minutes. It goes through your own Twilio account, which bills you for each text.
- Combined verification Both codes must pass. Use it where a signature has to hold up later, such as a guarantor's.
The signer confirms the email code first, then the SMS code. Use it for high-value or legally sensitive agreements.
How signing works
-
Signers receive their link
You send each signer a personal signing link by email or SMS. They do not sign in or install anything. They open the link, enter the code if you asked for one, and continue.
-
Read, then sign
The signer can sign only after scrolling through at least 80% of the contract. Enlivy records how long they read and how far they scrolled. Then they sign in the way you chose, by drawing, ticking a box or uploading a signed copy, and confirm the signature is legally binding.
-
A link to the signed contract
Each signer gets an email with a link to the signed contract in your client portal. Once all parties have signed, everyone gets the final version. If the contract came from a proposal, your client then goes on to pay.
Proposals, contracts, invoices and payments
Send your next contract for signature
Write the contract, send it, and see who has signed.
- Free to start
- No credit card required
- Price locked for two years
- EU e-invoices (EN 16931, Peppol BIS 3.0)
The signing experience
See what your signer sees
The real signing steps, start to finish: consent, the email and SMS codes, reading the contract, then signing it. Try it: nothing is sent and nothing is stored.
How to add a contract
Add a contract from the contract list.
-
Open Contracts
Go to Contracts in the left menu. All your contracts are in one table.
-
Choose your method
Click “Add Contract +” and choose Create Using Enlivy for a new contract, or Uploaded for a document made elsewhere.
-
Fill in details
Enter the contract’s information, parties, dates and content in its tabs: Information, Parties, General, Content Introduction and Chapter Details.
-
Track and manage
The contract then appears in your contract list. From there, follow its signatures and dates, and edit its details.
CONNECTED DOCUMENTS
See what refers to a contract
A contract's Connections tab lists the proposals, invoices, receipts, billing schedules, payslips and other contracts that refer to it, the ones your role can open. Go to the proposal a contract came from, or the invoices that followed, without searching separate lists.
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.
/organizations/<organization_id>/contracts # filters are optional and combinable
# pass a q=... param instead of ids to run a full-text search
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contracts' \
--data-urlencode 'page=1' \
--data-urlencode 'limit=20' \
--data-urlencode 'direction=outbound' \
--data-urlencode 'category=core' \
--data-urlencode 'include=contract_status,sender_user,receiver_user,contract_parties' \
--data-urlencode 'include_meta=navigation' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
// filters are optional and combinable
// pass a q=... param instead of ids to run a full-text search
const query = new URLSearchParams({
page: "1",
limit: "20",
direction: "outbound",
category: "core",
include: "contract_status,sender_user,receiver_user,contract_parties",
include_meta: "navigation",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts?${query}` , {
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
},
}).then((response) => response.json());Retrieve a single contract with everything attached: its chapters, its parties, the current pipeline status, the linked file, and the sender / receiver.
/organizations/<organization_id>/contracts/<contract_id> # available includes: organization, parent_contract, sender_user, receiver_user,
# file, contract_status, contract_chapters, contract_parties, contract_prefix
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>' \
--data-urlencode 'include=contract_chapters,contract_parties,contract_status' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";
// available includes: organization, parent_contract, sender_user, receiver_user,
// file, contract_status, contract_chapters, contract_parties, contract_prefix
const query = new URLSearchParams({
include: "contract_chapters,contract_parties,contract_status",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}?${query}` , {
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
},
}).then((response) => response.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.
/organizations/<organization_id>/contracts curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contracts' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"category": "core",
"source": "internal",
"direction": "outbound",
"organization_sender_user_id": "<org_user_sender_id>",
"organization_receiver_user_id": "<org_user_receiver_id>",
"organization_contract_status_id": "<contract_status_id>",
"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": "organization",
"party_country_code": "RO",
"organization_name": "Acme Studio SRL",
"organization_type": "srl",
"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
},
{
"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
}
]
}' const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts` , {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
"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",
// outbound | inbound
direction: "outbound",
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: [
// country-specific `information` (person) and `organization_information` (company)
// JSON blocks are also accepted; their shape is validated against the country schema.
{
// party_type, party_country_code, first_name, last_name are required on every party
// organization | individual
party_type: "organization",
party_country_code: "RO",
// organization parties additionally REQUIRE organization_name + organization_type
organization_name: "Acme Studio SRL",
// value comes from reference data
organization_type: "srl",
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,
},
{
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,
},
],
}),
}).then((response) => response.json());Update a contract’s metadata, move it to another status, adjust its chapters, or refine its parties. Send only what you want to change.
/organizations/<organization_id>/contracts/<contract_id> curl -X PUT 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"organization_contract_status_id": "<next_status_id>",
"sub_title": "2026 Engagement (revised)",
"ends_at": "2027-12-31 23:59:59"
}'const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}` , {
method: "PUT",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
"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",
}),
}).then((response) => response.json());Render and download the contract as a PDF, the same document your counterparties see.
/organizations/<organization_id>/contracts/<contract_id>/download # returns a file stream, read it as a blob, not JSON
curl 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>/download' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
--remote-name --remote-header-nameconst baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";
// returns a file stream, read it as a blob, not JSON
const pdf = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}/download` , {
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
},
}).then((response) => response.blob());Soft-delete a contract. It can be restored later.
/organizations/<organization_id>/contracts/<contract_id> # soft delete, restore via POST /contracts/restore/{contractId}
curl -X DELETE 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";
// soft delete, restore via POST /contracts/restore/{contractId}
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}` , {
method: "DELETE",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
},
}).then((response) => response.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.
/organizations/<organization_id>/contract-statuses curl -G 'https://api.enlivy.com/organizations/<organization_id>/contract-statuses' \
--data-urlencode 'page=1' \
--data-urlencode 'limit=50' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const query = new URLSearchParams({
page: "1",
limit: "50",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-statuses?${query}` , {
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
},
}).then((response) => response.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.
/organizations/<organization_id>/contract-statuses curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contract-statuses' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"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",
"direction": "any",
"order": 3,
"rgba_color_code": "rgba(59, 130, 246, 1)"
}'const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-statuses` , {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
"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.",
},
// draft | action_required | accepted | breach | terminated
contract_state: "action_required",
// inbound | outbound | any
direction: "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)",
}),
}).then((response) => response.json());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.
/organizations/<organization_id>/contract-signatures curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"organization_contract_id": "<contract_id>",
"organization_contract_party_id": "<party_id>",
"signature_source": "user_flow",
"sign_session_signature_types": [
"draw",
"checkbox"
],
"sign_session_required_confirmations": [
"email",
"legally_binding"
],
"expires_at": "2026-07-17 23:59:59"
}'const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures` , {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
"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",
// draw | checkbox | file_classic | file_electronic
"checkbox",
],
sign_session_required_confirmations: [
"email",
// email | phone | legally_binding
"legally_binding",
],
expires_at: "2026-07-17 23:59:59",
}),
}).then((response) => response.json());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.
/organizations/<organization_id>/contract-signatures/<contract_signature_id>/send curl -X POST 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures/<contract_signature_id>/send' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' \
-H 'Content-Type: application/json' \
-d '{
"method": "email",
"message": "Please review and sign the agreement by Friday."
}'const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractSignatureId = "<contract_signature_id>";
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures/${contractSignatureId}/send` , {
method: "POST",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
"Content-Type": "application/json" ,
},
body: JSON.stringify({
// email | sms
method: "email",
message: "Please review and sign the agreement by Friday.",
}),
}).then((response) => response.json());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.
/organizations/<organization_id>/contract-signatures/<contract_signature_id> # sign_session_url returns the hosted link to give to the signer.
# status is one of: pending | sent | completed | expired | void
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures/<contract_signature_id>' \
--data-urlencode 'include=sign_session_url,organization_contract' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractSignatureId = "<contract_signature_id>";
// sign_session_url returns the hosted link to give to the signer.
// status is one of: pending | sent | completed | expired | void
const query = new URLSearchParams({
include: "sign_session_url,organization_contract",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures/${contractSignatureId}?${query}` , {
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
},
}).then((response) => response.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.
/organizations/<organization_id>/contract-signatures # omit organization_contract_id to list sessions across every contract
curl -G 'https://api.enlivy.com/organizations/<organization_id>/contract-signatures' \
--data-urlencode 'organization_contract_id=<contract_id>' \
--data-urlencode 'include=sign_session_url' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
-H 'Accept: application/json' const baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
// omit organization_contract_id to list sessions across every contract
const query = new URLSearchParams({
organization_contract_id: "<contract_id>",
include: "sign_session_url",
});
const result = await fetch(`${baseUrl}/organizations/${organizationId}/contract-signatures?${query}` , {
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
Accept: "application/json" ,
},
}).then((response) => response.json());Pull the tamper-evident evidence package (authentication, consent, and signature biometrics captured during signing) for compliance and dispute handling.
/organizations/<organization_id>/contracts/<contract_id>/download-evidence # also available per session: /contract-signatures/{signatureId}/download-evidence
curl 'https://api.enlivy.com/organizations/<organization_id>/contracts/<contract_id>/download-evidence' \
-H "Authorization: Bearer $ENLIVY_API_TOKEN" \
--remote-name --remote-header-nameconst baseUrl = "https://api.enlivy.com" ;
const token = process.env.ENLIVY_API_TOKEN;
const organizationId = "<organization_id>";
const contractId = "<contract_id>";
// also available per session: /contract-signatures/{signatureId}/download-evidence
const evidence = await fetch(`${baseUrl}/organizations/${organizationId}/contracts/${contractId}/download-evidence` , {
method: "GET",
headers: {
Authorization: `Bearer ${token}`,
},
}).then((response) => response.blob());Where it fits
Part of these setups
Each page follows one way of selling and shows what your client does, which features you use and what they cost.
- Agencies and studios Core Drafted from your template with the client's details, and signed online, with an email or SMS code if you ask. See the setup
- Course authors Core Enrollment contracts signed online, with amendments in the same place. See the setup
- Sales teams Core Drafted from the accepted proposal and signed online, with an email or SMS code if you ask for one. See the setup
- Monthly billing Optional Adds a signed contract before the first charge. The signed version stays on the client's record. See the setup
Works together with
- Proposals Put the work, the price and the payment terms in one proposal. Your client accepts it from the email, and the contract and first invoice use the same price.
- Sales Pipeline See which leads are moving, read the last conversation before you follow up, and send the proposal from the lead's page.
- Document Intake Drop a supplier invoice or a receipt. With your own AI key, Enlivy fills in the form for you to check and save.
- Tasks Keep your team's work beside the invoices, leads and projects it concerns. Tasks are included for every organization at no extra charge, with no limit on the number of tasks.
- Users Clients, suppliers, and colleagues share one list in Enlivy. Open anyone's record to see what they owe you or you owe them, their documents, reports, and proposals, as far as your role allows.
- Customer Portal Your clients accept the proposal and sign the contract from the links in your emails, and pay an invoice from the payment link you send. In a portal with your logo, they find their invoices, contracts and subscriptions, and sign in with an email code instead of a password.
- MCP Connect Claude, ChatGPT, Cursor, or another MCP-compatible assistant to work with your invoices, contracts, and pipeline, within your own permissions.