Kommo + SignNow: Automatic Document Signing from the Pipeline

SignNow is an electronic signature platform with a REST API, eIDAS compliance (EU), and ESIGN Act compliance (US). In terms of functionality it is comparable to DocuSign and Adobe Sign, but significantly cheaper. The Kommo integration closes the pattern “deal on stage -> document signed -> CRM updated” without manual data copying and without the manager switching to a different interface.

SignNow vs DocuSign vs Adobe Sign: When to Choose SignNow

All three platforms cover the basic task — send a document for signing and receive a legally valid signature. The choice is determined by price, API availability, and ecosystem:

SignNow falls behind on ecosystem (DocuSign has more native connectors), but wins on price for API integrations. For companies building a custom CRM connection, this is the key parameter.

Similar integration patterns have been implemented for DocuSign and Adobe Sign — the architecture is identical, only the SignNow API changes.

What Gets Synchronised

Kommo -> SignNow: — Deal contact name and email -> recipient of the invite — Deal name -> subject of the document email — Custom field data -> substitution into document template (merge fields) — Deadline from Kommo field -> signing deadline (expiration_days)

SignNow -> Kommo: — invite.update event (status signed) -> “Document Signed” field in deal — Move deal to next pipeline stage — Link to signed document -> Note on deal — Signing date -> custom field

Integration Architecture

Kommo Webhook: deal moved to "Contract Signing" stage
  ↓ Backend
  1. GET /api/v4/leads/{id} + contacts
     -> name, email, amount, custom fields
  2. Generate PDF from template with client data
  3. SignNow API: POST /document (upload PDF)
     -> get document_id
  4. SignNow API: POST /document/{id}/fieldinvite
     -> send invite to client
  5. Kommo: PATCH /leads/{id}
     -> update signnow_document_id field

SignNow Webhook: invite.update (status = signed)
  ↓ Backend
  1. Extract document_id from payload
  2. GET kommo_deal_id from document custom field
  3. SignNow API: GET /document/{id}/download
     -> save signed PDF
  4. Kommo: PATCH /leads/{deal_id}
     -> signed = true, stage -> "Contract Received"
  5. Kommo: POST /leads/{deal_id}/notes
     -> link to document + signing date

SignNow REST API: Key Requests

SignNow uses OAuth 2.0 (Password Grant for service account). Endpoint: api.signnow.com.

Get access token:

import requests
import base64

credentials = base64.b64encode(f'{CLIENT_ID}:{CLIENT_SECRET}'.encode()).decode()
response = requests.post(
    'https://api.signnow.com/oauth2/token',
    headers={
        'Authorization': f'Basic {credentials}',
        'Content-Type': 'application/x-www-form-urlencoded'
    },
    data={
        'username': SN_USER,
        'password': SN_PASS,
        'grant_type': 'password',
        'scope': '*'
    }
)
access_token = response.json()['access_token']

Upload document:

with open(pdf_path, 'rb') as f:
    response = requests.post(
        'https://api.signnow.com/document',
        headers={'Authorization': f'Bearer {access_token}'},
        files={'file': (filename, f, 'application/pdf')}
    )
document_id = response.json()['id']

Send for signing (field invite):

invite_data = {
    'from': SENDER_EMAIL,
    'to': [
        {
            'email': client_email,
            'role': 'Signer 1',
            'order': 1,
            'reassign': '0',
            'decline_by_signature': '0',
            'reminder': 3,
            'expiration_days': expiration_days or 14,
            'subject': f'Agreement for deal {deal_name}',
            'message': f'Dear {client_name}, please find the agreement attached for your signature.'
        }
    ]
}
requests.post(
    f'https://api.signnow.com/document/{document_id}/fieldinvite',
    headers={'Authorization': f'Bearer {access_token}'},
    json=invite_data
)

Register webhook:

requests.post(
    'https://api.signnow.com/api/v2/events',
    headers={
        'Authorization': f'Bearer {access_token}',
        'Content-Type': 'application/json'
    },
    json={
        'event': 'invite.update',
        'entity_id': document_id,
        'action': 'callback',
        'attributes': {
            'callback': 'https://yourbackend.com/signnow/webhook',
            'use_tls_12': True
        }
    }
)

Document Templates and Merge Fields

SignNow supports templates with fillable fields. A template-based workflow is more efficient than uploading a new PDF for each deal:

1. Create a template in the SignNow UI with fields: {{client_name}}, {{company}}, {{amount}}, {{date}}
2. When creating a document, use POST /template/{template_id}/copy — SignNow creates a copy with a new document_id
3. Update text fields via PUT /document/{id} with data from Kommo
4. Send field invite

This approach eliminates the need to generate a PDF on the backend — data is substituted directly into the SignNow template.

Handling Multiple Signatories

If the agreement requires signatures from both parties (client + manager), field invite supports multiple recipients with a signing order:

'to': [
    {
        'email': client_email,
        'role': 'Client',
        'order': 1,  # signs first
        'expiration_days': 14,
        ...
    },
    {
        'email': manager_email,
        'role': 'Company Representative',
        'order': 2,  # receives invite after client signs
        'expiration_days': 7,
        ...
    }
]

The invite.update webhook fires for each signing. The complete status of “all signed” is determined by the document.complete event.

Real-World Case

Legal company (EU market, 30–40 contracts per month, clients in 5 countries):

• Before: the manager manually uploaded the PDF to SignNow, entered the client’s email, and sent it. After signing — manually updated the stage in Kommo. Average time from Won to document send: 2 days.
• After: Won in Kommo -> client receives the agreement by email within 2 minutes -> after signing, Kommo automatically moves to the “Contract Received” stage with a note and date.
• Additional effect: the manager receives a Kommo notification immediately after signing and can raise an invoice right away. The cycle from Won to invoice shortened from 5 days to a few hours.

A similar pattern was implemented for PandaDoc and Kommo — there the integration is native, but SignNow is more cost-effective at 30+ documents per month.

Who This Is Relevant For

• SignNow is used (or being considered as a cheaper alternative to DocuSign/Adobe Sign)
• 10+ contracts per month currently sent manually
• Clients in the EU or US — eIDAS and ESIGN Act compliance is required
• Full traceability is needed: who signed, when, and what stage the deal is in
• The two-way cycle is important: Won -> document -> signature -> next pipeline stage

Frequently Asked Questions

Is there a native SignNow and Kommo integration?

There is no native integration. SignNow is not listed in the Kommo Marketplace. The integration is built via the SignNow REST API and Kommo webhooks — this is 2–3 weeks of development. The difference from a Zapier approach: full control over logic, merge fields from templates, multi-stage signing, and two-way status synchronisation.

Which plan includes the SignNow API?

The SignNow API is available via Site License or a separate API plan. The entry-level API plan is around $146/month for 1,000 invites per year. There is a free trial with 250 invites for testing. Standard plans (Business, Business Premium) do not include API access.

How do I pass Kommo data into a SignNow template?

Via the SignNow template mechanism: create a template with fillable fields, create a copy of the template for each deal (POST /template/{id}/copy), fill fields with Kommo data via PUT /document/{id}. This eliminates the need to generate PDFs on the server side.

Can I send a reminder about an unsigned document?

Yes. The reminder parameter in the field invite sets the reminder interval in days. Additionally, logic can be implemented on the Kommo side: if the “Document Signed” field is empty after N days — send a task to the manager or automatically resend the invite via API.

Does SignNow support embedded signing?

Yes. SignNow supports embedded signing — the document can be opened for signing directly inside your interface (for example, in a client portal). Use the endpoint POST /document/{id}/session to get a temporary iframe URL. This is relevant when the client works in your portal and redirecting to a third-party site is undesirable.

Summary

• SignNow REST API: OAuth 2.0, document upload, field invite with multiple signatories, webhook on invite.update and document.complete
• Templates with merge fields — Kommo data is substituted without generating PDFs on the backend
• Cycle: Won -> document -> signature -> stage update in Kommo — fully automatic
• SignNow is cheaper than DocuSign and Adobe Sign with comparable functionality for custom integrations
• Typical development time: 2–3 weeks

If you use SignNow and want to automate document sending from Kommo — describe your template structure and signing workflow. Exceltic.dev will analyse the field mapping and propose an architecture.