When Kommo and Juro are integrated, a contract is generated from deal data in one click: client name, amount, terms - everything is pulled from the card fields. After signing, Juro returns the status and a document link back to Kommo. The manager never opens Word or copies details by hand.
Juro is a contract lifecycle management platform with a built-in AI assistant that helps draft, edit, and analyze agreements. For companies where every deal ends in a contract, the gap between Kommo and Juro is expensive: managers spend 20-40 minutes on each agreement, make mistakes when copying details, and have to track signing status manually.
According to Juro, companies spend an average of 2-3 hours preparing and reviewing a single B2B contract manually - that covers finding the right template, filling in details, sending for legal review, and resending after revisions. Contract management platforms (Juro, DocuSign, PandaDoc) are growing rapidly in EU B2B precisely as a response to that bottleneck. There is no native Kommo-Juro integration: when a deal is won, the contract is created by copying data from the deal card by hand. A custom webhook closes this point - data from Kommo custom fields flows into Juro automatically. The architecture and implementation details are below.
Why the native integration does not work
Juro has no ready-made widget for Kommo. A Zapier connector for Juro exists, but it only works in one direction: a trigger on a Juro event sends data to another service. Creating a document in Juro from a Kommo event via a standard Zapier trigger is not possible - there is no suitable action.
The problem goes deeper than a missing connector. Juro works with concepts like “contract workflow,” “counterparty,” and “signatory” - these do not map directly to “deal,” “contact,” and “company” in Kommo. Without server-side logic to transform the data, the integration will be incomplete.
An additional complexity: Juro supports multi-party signing - when a contract must be signed by several people. No no-code tool can correctly pass a list of signatories from Kommo fields into a Juro workflow.
What gets built - solution architecture
Kommo (deal moved to "Contract" stage)
|
v
Orchestrator server
- reads deal data via Kommo API
- maps fields to Juro template variables
|
v
Juro API (create document from template)
|
v
Juro (document in Draft status)
|
Juro sends to counterparty for signing
|
v
Juro webhook (status changed: SIGNED / DECLINED)
|
v
Kommo API (update field + add note + attach link)Three key Juro fields are used when creating a document:
template_id- ID of the contract template in Jurocounterparty- object with name, email, and title of the signatory on the client sidecustom_fields- template variables: amount, term, service description
Technical details
Juro API v2 uses a Personal Access Token (PAT) for authentication - the token is passed in the Authorization: Bearer <token> header. The API supports creating documents from templates, managing workflows, and retrieving statuses. Webhooks are configured in Settings -> Integrations -> Webhooks in the Juro UI.
import requests
JURO_API_URL = "https://paper.juro.com/api"
JURO_TOKEN = "your_personal_access_token"
def create_contract_from_kommo_deal(deal_data: dict) -> dict:
"""
Creates a contract in Juro from Kommo deal data.
deal_data: deal data retrieved from the Kommo API
"""
headers = {
"Authorization": f"Bearer {JURO_TOKEN}",
"Content-Type": "application/json"
}
# Mapping Kommo fields -> Juro
payload = {
"templateId": "tmpl_your_template_id",
"name": f"Contract - {deal_data['name']}",
"counterparties": [
{
"name": deal_data["contact_name"],
"email": deal_data["contact_email"],
"role": "signatory"
}
],
"customFields": {
"deal_amount": str(deal_data["price"]),
"currency": deal_data["currency"] or "USD",
"service_description": deal_data.get("service_description", ""),
"contract_term_months": str(deal_data.get("contract_term", 12)),
"client_company": deal_data.get("company_name", "")
}
}
resp = requests.post(
f"{JURO_API_URL}/v2/documents",
json=payload,
headers=headers
)
resp.raise_for_status()
return resp.json()
def send_for_signing(document_id: str) -> bool:
headers = {"Authorization": f"Bearer {JURO_TOKEN}"}
resp = requests.post(
f"{JURO_API_URL}/v2/documents/{document_id}/send",
headers=headers
)
return resp.status_code == 200Step-by-step implementation
Step 1. Prepare the contract template in Juro
In Juro, create an agreement template with variables in {{variable_name}} format. A standard set: {{deal_amount}}, {{client_company}}, {{service_description}}, {{contract_term_months}}. Record the templateId - it is visible in the URL of the template page.
Step 2. Configure custom fields in Kommo
Add fields: juro_document_id (text), juro_status (dropdown: DRAFT/SENT/SIGNED/DECLINED), juro_document_url (link). These fields will be populated automatically after the document is created.
Step 3. Create a Kommo webhook on stage change
Configure a webhook for the leads.status event. When a deal moves to the “Contract” stage (specify the exact status_id), the server calls create_contract_from_kommo_deal.
Step 4. Deploy the Juro webhook handler
from flask import Flask, request, jsonify
app = Flask(__name__)
@app.route("/juro/webhook", methods=["POST"])
def juro_webhook():
data = request.json
event_type = data.get("type") # document.signed, document.declined
document_id = data["document"]["id"]
# Find the deal by juro_document_id
lead = kommo_api.find_lead_by_custom_field("juro_document_id", document_id)
if not lead:
return jsonify({"error": "Lead not found"}), 404
if event_type == "document.signed":
kommo_api.update_lead(lead["id"], {
"juro_status": "SIGNED"
})
kommo_api.move_to_stage(lead["id"], SIGNED_STAGE_ID)
signed_url = data["document"].get("signedPdfUrl", "")
kommo_api.add_note(
lead["id"],
f"Contract signed. Document: {signed_url}"
)
elif event_type == "document.declined":
kommo_api.update_lead(lead["id"], {"juro_status": "DECLINED"})
kommo_api.add_note(
lead["id"],
f"Contract declined by counterparty. Reason: {data.get('reason', '-')}"
)
return jsonify({"ok": True})Step 5. Configure the Juro webhook
In Juro -> Settings -> Integrations -> Webhooks, add the URL https://yourserver.com/juro/webhook. Subscribe to the events document.signed and document.declined.
Real case with numbers
An Amsterdam IT company selling SaaS solutions to enterprise clients in Europe. 30-50 contracts per month, each customized with variations in amount, term, and service scope.
Before the integration:
- Manager received notification that the deal closed
- Opened a Word template, copied details from Kommo manually
- Sent to Juro for legal review
- After signing, manually updated the status in Kommo
- Attached a link to the document in a note
Time per operation: 25-35 minutes. With 40 contracts per month - 17-23 hours of manager time.
Error rate: 8-12% of contracts contained typos or wrong figures due to manual copy-pasting. Corrections required restarting the signing process.
After the integration via Exceltic.dev:
- Contract is generated automatically on stage transition: manager reviews in 2-3 minutes
- Errors from manual copying: 0
- Signing status updates in Kommo in real time
- Time saved: 18-20 hours per month
More on custom Kommo CRM integrations and what automation scenarios have already been implemented.
Who this is for
The Kommo + Juro integration is optimal for:
- B2B companies with 20+ contracts per month where manual work has become a bottleneck
- Companies with legal approval workflows - Juro supports internal approval before sending to the client
- Teams working with international clients - Juro supports eSignature compliant with eIDAS (Europe) and the ESIGN Act (US)
- SaaS and agencies where a contract is a standard part of the pipeline rather than an exception
If you need simpler electronic signatures without the AI features, look at DocuSign or SignNow integrations. Juro wins specifically where template management, collaborative editing, and AI contract analysis matter.
Frequently asked questions
Does Juro support legally binding signatures in non-EU jurisdictions?
Juro is oriented toward international markets: US, UK, EU. Signatures comply with eIDAS (Europe) and the ESIGN Act (US). Juro is not suitable for jurisdictions that require local certification authorities - consult your legal counsel for those cases.
Can multiple contract templates be used?
Yes. You can add a “Contract type” custom field (dropdown) in Kommo, and the orchestrator server will select the appropriate templateId based on the value. For example: NDA, Service Agreement, Subscription Agreement - each with its own set of variables.
How does internal contract approval work before sending to the client?
Juro supports an internal approval workflow: after the document is created, it passes through a list of approvers (legal, CFO) and is only sent to the client for signing after final sign-off. The integration can track the approval status and notify the manager in Kommo via notes or custom field changes.
How should I structure the Kommo pipeline around a Juro workflow?
An optimal stage structure: “Qualification” -> “Proposal Sent” -> “Contract” (this triggers document creation in Juro) -> “Pending Signature” -> “Signed” -> “Delivery.” With this structure the transition between “Contract” and “Pending Signature” happens automatically after the document is sent, and “Signed” triggers on the document.signed event from Juro.
How much does integration development cost?
A standard project with one template, basic field mapping, and webhook handling takes 2-3 weeks of development. Complex scenarios - multiple templates, multi-party signing, internal approval - add 1-2 weeks. We provide an exact estimate after reviewing your stack.
If contracts are a standard part of your pipeline and you want to eliminate manual work - describe your requirements to the Exceltic.dev team. We will design the architecture around your templates and estimate the scope.