End-to-end Telegram → amoCRM analytics: how to connect a channel, bot, and CRM

A common request from companies that sell through Telegram: traffic comes into a channel, then moves into a bot on a no-code builder, and deals get closed in amoCRM. The customer’s path stretches across three systems, and without end-to-end analytics it’s hard to tell which traffic source actually drives sales — or at which stage of the funnel subscribers drop off.

Here’s how Graspil handles this — using a typical setup as an example: channel → bot on a third-party builder → amoCRM, where you need to see who joined the channel and when, which link brought them into the bot, and what stage their deal is currently at in the CRM.

How it works

The setup is built on three connected pieces:

1. Tagging the channel. Traffic into the channel is tagged with UTM parameters — through Telegram invite links (for internal Telegram traffic) or through Graspil’s tlin.cc links (for external traffic, from ads or a website).
2. Linking the channel and the bot by user. Graspil identifies users by their Telegram user_id. When the same person who joined the channel through a tagged link later starts the bot, Graspil recognizes them and continues the funnel without losing the source. The start parameter isn’t required for this — it’s an optional extra way to pass tags directly into the bot, for example for external traffic via tlin.cc links, or to mark which post someone came from.
3. Passing tags into amoCRM. When the bot is started, Graspil finds the matching deal/contact in amoCRM and writes the tags into its fields — usually using amoCRM’s built-in UTM fields.

As a result, Graspil’s reports show the whole funnel at once: joining the channel → starting the bot → deal stages in the CRM, with no manual exports needed.

Important: end-to-end analytics (channel + bot) isn’t mandatory. If you don’t have a channel, or don’t need to track it, you can connect just the bot and pass bot-level tags into amoCRM (the source that brought someone into the bot itself) — that works fully on its own and doesn’t require a channel.

Connecting a bot that’s already running on a builder

A common question: “our bot is already connected to a third-party builder — can we add it to Graspil without breaking what’s already working?”

Yes. The recommended method is auto-connection by token (MtProto protocol). It runs in parallel with the bot’s existing connection to the builder and doesn’t interfere with it: the builder keeps processing messages exactly as before, while Graspil receives data separately, over MtProto.

If you plan to use UTM tags inside the bot itself (not just at the channel level), it’s worth checking in advance whether your bot supports passing parameters through start — some builders restrict this. There’s a separate guide in the documentation on how to check.

How tags reach amoCRM

The amoCRM integration in Graspil is write-only: Graspil updates fields on a deal, but doesn’t read data from amoCRM directly. The logic is configured through the automation builder: which action to run (create a deal, update an existing one, or just push tags into one that’s already linked), and which amoCRM fields to write which data into — set up as a mapping.

One amoCRM quirk worth knowing: as soon as Graspil (or anyone else) edits a deal and writes something into its fields, the deal automatically moves out of the “Unsorted” category. That’s a limitation of amoCRM itself, not Graspil — but it affects the process. If it matters to you that deals first pass through “Unsorted” manually, factor that in when setting things up.

The other direction: events from amoCRM into Graspil

This is the most individual part of the setup. If you want your analytics to show not just “reached the bot” but also “reached payment” or “moved to a specific deal stage,” events need to be passed from amoCRM back into Graspil. Two options:

By keyword — if the conversation with the client happens as text inside the bot, you can set up a trigger that fires a target event on a phrase like “Thanks for your order.”

Via a webhook on deal stage change — if managers work inside amoCRM and never write in the bot, the only option is to send a webhook from amoCRM to Graspil when a deal’s status changes.

The key question here is matching: which field the incoming webhook uses to link to a specific user in Graspil. This part is configured individually, based on your funnel and the field structure in your amoCRM.

How to connect it

1. Connect the channel and the bot. Both guides are in the documentation — connecting a bot, connecting channels.
2. Connect the integration. In the “Integrations” section, authorize and connect amoCRM or Kommo.
3. If you need end-to-end UTM passing — in the resource settings (for the channel), link it to the bot. After that, the tags a user arrived with in the channel also become available in the bot.
4. Create an automation to export data. Trigger — bot start (or any other event you need), action — the amoCRM/Kommo integration, where you specify which data goes into which fields.
5. If you need data passed back from amoCRM — set up a webhook to the Graspil API, or track keywords in the bot’s messages (see above).
6. Build the report. The most obvious option is an end-to-end funnel broken down by UTM: step one — joined the channel, step two — started the bot, then sales events and any other steps you need.

If any of this looks complicated, or you’d like a non-standard setup — reach out to support, we’ll help set everything up.

Summary

Connecting Telegram channel → bot → amoCRM is done with Graspil’s standard tools, without reworking the bot’s existing setup. End-to-end analytics (with a channel) gives a fuller picture but isn’t required — you can stick to bot-level tags. Passing data into amoCRM is set up through automations, and events coming back from the CRM go through webhooks, configured individually around your field structure and funnel.