Kommo + GetAccept: automating document sending from the sales pipeline

The deal is at the final stage — the client is ready, all that remains is to send the proposal or contract. Without integration, the manager opens GetAccept, manually creates a document, copies details from Kommo, selects a template, adds recipients, and sends. Then periodically checks GetAccept to see whether the client has opened the document. After signing, returns to Kommo and manually changes the deal stage. A custom integration removes all this manual work: the document is sent automatically, and signing instantly closes the deal in the pipeline.

Why no native integration exists

GetAccept is completely absent from the Kommo marketplace — neither an official connector nor popular third-party solutions via Zapier or Make. The products barely intersect in the automation ecosystem despite GetAccept being one of the market leaders in sales document automation.

This is not a complexity issue — GetAccept provides one of the cleanest and most developer-friendly APIs on the e-signature market. The problem is the absence of a ready-made connector. A custom integration via the GetAccept API fully solves the problem and is built faster than comparable DocuSign solutions.

What GetAccept is and how it differs from DocuSign

GetAccept is not just an electronic signature tool. It is a sales document automation platform with features DocuSign lacks:

• Deal Room — a personal buyer space where all deal materials are gathered: proposal, presentation, contract, video message from the manager
• Document Engagement Tracking — detailed analytics: when the client opened the document, how long they spent on each page, which sections they read the longest
• Video messaging — the manager records a personal video directly in the GetAccept interface and attaches it to the document
• Smart proposals — interactive commercial proposals with pricing tables where the client can choose options

For companies with a long deal cycle and high average deal value, this is a fundamentally different level of document handling compared to simple electronic signatures.

What the Exceltic.dev custom integration solves

• Automatic document sending — when the deal moves to the “Send Proposal” or “Send Contract” stage, the GetAccept document is created and sent automatically
• Prefill from deal fields — company name, contact name, deal amount, timelines, service descriptions — all data from Kommo fields is substituted into the GetAccept template merge tags via custom_fields API
• Automatic stage transition — upon receiving the document:signed event, the deal in Kommo instantly moves to the “Contract Signed” stage
• Engagement notifications in Kommo — upon the document:opened event, a note is created in the deal card: “Client opened the document” with a timestamp. The manager sees this directly in Kommo and can call at the right moment
• Reverse synchronization — data filled in by the client in the document is passed back to custom deal fields in Kommo
• Decline notification — the document:declined event creates a task for the manager with the reason for refusal
• Expiry reminder — the document:expired event automatically creates a task and moves the deal to the “Requires Attention” stage
• Different templates for different pipelines — the “New Clients” pipeline uses a proposal template, the “Renewal” pipeline uses a renewal contract template

How the integration works — technical process

Connection architecture

The integration is built on the Kommo Webhooks → Exceltic middleware → GetAccept API v1 stack. Authentication with GetAccept is implemented via Bearer Token — the simplest and most reliable method for server-side integrations. Reverse synchronization works via GetAccept Webhooks, which send events on every document status change.

The GetAccept API compares favorably to DocuSign in architectural cleanliness: a single POST /v1/documents request with a recipients array, custom_fields object, and template_id creates and sends the document with prefilled data. This simplifies the middleware and speeds up development.

Step-by-step workflow

1. Manager moves the deal to the “Send Proposal” stage in Kommo
2. Kommo sends a webhook with the deal ID to the middleware endpoint
3. Middleware requests deal data GET /api/v4/leads/{id} and contact data GET /api/v4/contacts/{id}
4. template_id is determined from the configuration table by pipeline type
5. Request to GetAccept API is formed with recipients, custom_fields, and template_id
6. Document is created and sent: POST /v1/documents
7. GetAccept returns document_id and a link to the document
8. Middleware writes document_id and the link to custom Kommo deal fields: PATCH /api/v4/leads/{id}
9. When the client opens the document — Webhook document:opened creates a note in Kommo
10. On signing — Webhook document:signed moves the deal to the “Contract Signed” stage
11. Data from filled document fields is written to custom Kommo contact fields

Engagement notifications: why this matters

Engagement tracking is one of GetAccept’s main advantages over DocuSign. When the middleware receives a document:opened event with viewing data (open time, pages, time per page), this data is written to the Kommo deal timeline. The manager sees the exact moment the client is reviewing the proposal and can call “while the iron is hot” — conversion on such calls is significantly higher.

What happens on error

GetAccept API returns standard HTTP error codes with detailed messages. On 404 Template Not Found — immediate notification to the integration administrator. On 429 Rate Limit — queue with delay. If GetAccept is unavailable — the event is saved to a queue with exponential backoff: retries after 1, 5, and 15 minutes.

Real-world case

Architecture firm, 3 managers, ~25 deals per month, clients in EU.

The company worked with two types of documents: a commercial proposal (proposal with project description, phases, and pricing) and a design services contract. The proposal was sent manually — the manager created the document from scratch in GetAccept each time, copying project data from Kommo. Each proposal took 25–30 minutes.

The main pain was lack of visibility: managers did not know whether the client had looked at the proposal and which sections interested them. Calls were made blindly — often too early or too late.

After the integration launched, the proposal is sent automatically on stage change. When the client opens the document — a note with the open time appears in Kommo. Managers began calling within 15–20 minutes of the proposal being opened. Proposal-to-signed-contract conversion grew from 34% to 51% over three months.

Result: 12 hours per month returned to the team, proposal conversion grew by 50%, cycle from sending to signing shortened from 6.4 to 3.1 days.

Which businesses benefit most

The integration is most relevant for companies with high average deal value and long sales cycles: architecture and engineering firms, IT outsourcing, consulting, advertising agencies. Anywhere the proposal is not just a document but a persuasion tool, and it matters to understand how the client interacts with it.

GetAccept is especially effective for B2B companies with multiple stakeholders on the client side — Deal Room allows gathering all materials in one place and tracking which members of the client’s team have reviewed the documents.

Frequently asked questions

How does GetAccept differ from DocuSign for Kommo integration?
DocuSign is an electronic signature tool focused on the legal validity of the document. GetAccept is a sales document automation platform with Deal Room, engagement tracking, and video messages. For sales teams, GetAccept provides significantly more data on buyer behavior. From an integration standpoint, the GetAccept API is simpler and cleaner than the DocuSign API, which speeds up development.

Can you track which pages of the proposal the client read the longest?
Yes. GetAccept passes detailed engagement data via Webhooks: open time, total viewing time, time per page. The middleware writes this data to the Kommo deal timeline — the manager sees the full picture of how the client interacted with the document.

Does the integration support GetAccept Deal Room?
Yes. When creating a document via API, Deal Room can be activated — a personal buyer space. The Deal Room link is written to a custom Kommo deal field and can be sent to the client via Salesbot.

What happens if the client does not open the proposal for several days?
On the document:expired event (document expiry), the middleware creates a task for the manager in Kommo. Additionally, an intermediate trigger can be configured: if the document:opened event is not received after 72 hours — a task is created: “Client has not opened the proposal — follow up.”

How long does developing the Kommo and GetAccept integration take?
Basic integration with prefill, automatic stage transition, and engagement notifications — 3–5 business days. Version with multiple templates, Deal Room, and reverse data synchronization — 6–8 business days. The GetAccept API is significantly simpler than DocuSign, which reduces development time.

If you want to automate sending proposals and contracts from Kommo via GetAccept — describe the task to the Exceltic.dev team. We will review the scenario and propose an architecture suited to your document workflow.