Works with Make, formerly Integromat

AI Chatbot for Make: four chat events, thousands of apps, nothing in between

Asyntai connects to Make both ways. There is a native Asyntai AI Chatbot app in Make — four modules, one API key — so any scenario can ask the chatbot a question and use the answer. And four chat events can start a scenario, carrying an escalation or a new conversation into a task, a row, a CRM note, or the right channel. You supply the scenario. Make supplies the logins.

Get Started Free See the setup

See what the chatbot would answer

Enter your website and watch the AI answer questions using your own content — the same answers your automations will be reacting to.

Why a deliberately simple webhook makes Make so useful

Most chat tools try to own the whole workflow. They ship a Slack integration, then a Trello integration, then a half-finished CRM integration, and the one app your team actually lives in is never on the list.

Asyntai took the other road. The webhook sends a JSON POST and signs it. That is all it does. It cannot attach a bearer token, an OAuth header, or a per-app secret — and it does not need to, because that is the job you hand to Make. Make's Custom webhook accepts an unauthenticated JSON POST at a unique generated URL, and from that point on every downstream connection is Make's problem, not yours. Make's own site advertises more than 3,000 pre-built apps on the other side of that line.

One integration to build. Everything Make already connects to, for free, on the far end of it.

The practical effect is that the chatbot stops being a silo. A visitor asking for a human at 11pm is no longer a line in a transcript nobody reads — it is a task, an alert, a row, a record, created the second it happens.

The four chatbot events you can automate

Each webhook you register in Asyntai listens to whichever of these you tick. One scenario can watch a single event or all four.

conversation.started
A visitor opened a new conversation. Carries the session id, the page they were on, and the device type.
message.received
A visitor sent a message and the chatbot answered. Carries the question, the answer, the session id and the page URL.
escalation.requested
Someone asked for a human. Carries the session id and the message that triggered it.
takeover.started
One of your agents took over the conversation from the chatbot. Carries the session id and the agent name.

How to connect the chatbot to a Make scenario

The order matters: build the Make side first, because you need the generated URL before Asyntai has anywhere to send anything.

1. Make
Custom webhook module generates a URL
2. Asyntai
Paste the URL, pick events, set a secret
3. Sample
One real chat teaches Make the fields
4. Act
Map the fields into any Make module

The four steps in full

Create a Custom webhook in Make. Start a new scenario, choose Webhooks → Custom webhook as the trigger, and add a webhook. Make creates a unique URL and starts listening on it. Copy the address.
Register it in Asyntai. Open Settings → API, add a webhook, and paste the Make URL. Tick the events you care about and set a secret — Asyntai uses it to sign each delivery. Webhooks are part of the paid plans.
Let Make learn the shape of the data. Make works out the data structure from a real request, so leave the webhook module listening and trigger the event once — open your own chat widget and ask the chatbot a question. If you change events later, reopen the module and use Re-determine data structure, then send another sample.
Add the modules that do the work. Every field in the payload is now mappable. Drop in a Slack, Notion, Google Sheets, HubSpot or HTTP module and drag the values into place. Turn the scenario on.
What Asyntai POSTs to your Make webhook
// Headers: Content-Type: application/json // X-Webhook-Event: escalation.requested // X-Webhook-Signature: <HMAC-SHA256 of the body, using your secret> { "event": "escalation.requested", "payload": { "session_id": "s_8f31c0a4", "message": "Can I speak to a real person about my order?" } }

Once Make has seen one of those, the fields appear in the mapping panel of every later module. In Make's expression syntax they look like this, where 1 is the webhook module's number:

Mapping the payload in a downstream module
Task title: Escalation from {{1.payload.session_id}} Task body: {{1.payload.message}} Event type: {{1.event}}

No authentication header is exchanged in either direction here. The Make URL is unique and unguessable, and the signature in X-Webhook-Signature lets you confirm a delivery really came from your account.

Three scenarios worth building first

Each of these is a Custom webhook trigger plus one or two modules. None of them needs code.

A visitor asks for a human, and a task appears

This is the one to build on day one. The moment the chatbot hands over, the request becomes a real item in whatever your team works from — a card, a ticket, an issue, an assigned task — with the visitor's actual question in the description instead of "someone needs help".

escalation.requested→Custom webhook→Create a task→Notify the channel

Every new conversation logged as a row

The conversation.started payload includes the page the visitor was on and the device they used. Push that into a spreadsheet and after a fortnight you can see which pages create questions — which is usually a much shorter list than anybody expects, and the fastest content fix you will find.

conversation.started→Custom webhook→Add a spreadsheet row

Chat questions appended to the CRM record

The message.received payload carries both the question and the chatbot's answer. Route it through a search step to find the matching contact by session or email, then append the exchange as a note. Sales opens a record and sees what that person was actually trying to find out.

message.received→Custom webhook→Search contact→Append note

The other direction: Make can ask the chatbot too

Events flowing out are only half of it. For the way back in there is nothing to hand-build — Asyntai has its own app in Make. In a scenario, add a module, search for Asyntai AI Chatbot, click Add Connection and paste your API key. That is the whole setup.

Send Message to AI — the action you will use most. Pass a customer message and a session ID, get an answer drawn from your own content, and map it into the next module.
List Websites — returns every website on your account with its id, domain and primary flag, so a scenario can pick the right one.
Get Conversation History — pulls the message history for a session, useful when a human needs the full thread.
Make an API Call — the universal module, for any endpoint the dedicated three do not cover.

That turns any scenario into a place your chatbot can answer: drafting an email reply, suggesting a first response on a ticket, or answering an internal question posted in a channel. Pass a stable value as the session ID and follow-up calls are understood as one thread. Setup walkthrough lives in the Make integration guide, and the underlying endpoints are in the API documentation.

What the Make connection adds to your chatbot

One webhook, every app

You configure a single URL. Make holds the OAuth connections and API keys for everything downstream, and swapping the target app never touches Asyntai.

Signed deliveries

Each POST carries an HMAC-SHA256 signature of the body, generated from the secret you set, so a delivery can always be checked against your account.

Answers from your own content

The chatbot answers using your own pages, documents and FAQ entries — so what reaches your automations is grounded in what you actually published.

30+ languages, one payload

Visitors get replies in their own language automatically. The event payload looks identical whatever language the conversation happened in.

Filters and routing for free

Make's filters and routers mean you can escalate only certain pages, or send weekend requests somewhere different, without any logic living in the chatbot.

Two-way by design

Events out through the webhook, questions in through the REST API. The same chatbot serves your website visitors and your internal scenarios.

What this actually costs

Two bills, and it is worth being clear about both before you start building.

  • Asyntai. Webhooks and the REST API need a paid plan — Starter, Standard or Pro. The free plan gives you 100 messages a month to try the chatbot itself, but no API or webhook access. See pricing.
  • Make. A separate product with its own subscription. Make does offer a free plan, currently listed as up to 1,000 credits a month with 2 active scenarios — enough to prove one automation works. A busy site firing message.received on every exchange will move you onto a paid Make plan quickly, so start with the events that matter rather than all four.

Make chatbot questions

How do I connect an Asyntai chatbot to Make?

Add a Custom webhook module as the first step of a scenario. Make generates a unique URL and listens on it. Copy that URL into Asyntai under Settings → API, choose the events, and set a signing secret. Trigger one real chat so Make can determine the data structure, then add your action modules and map the fields.

Which chat events can start a scenario?

Four: message.received, conversation.started, escalation.requested and takeover.started. Tick any combination per webhook, so a scenario can watch one event or all of them.

Does the webhook need an authentication header?

No, and it cannot send one. Asyntai POSTs plain JSON and signs the body with an HMAC signature in X-Webhook-Signature. Make's Custom webhook accepts a JSON POST with no auth header, which is precisely why the pairing works — Make then holds the credentials for every downstream app.

Can a scenario send a question back to the chatbot?

Yes, and there is a native module for it. Search for Asyntai AI Chatbot when adding a module, connect it with your API key, and use Send Message to AI — pass a message and a session ID, and the answer comes back ready to map. List Websites, Get Conversation History and a universal Make an API Call module are included too.

What does it cost?

Webhooks and the API are on the paid Asyntai plans (Starter, Standard, Pro); the free plan's 100 monthly messages do not include them. Make bills separately — its free plan currently lists up to 1,000 credits a month and 2 active scenarios, and heavier use needs a paid Make plan.

Other ways to wire the chatbot in

The same four events and the same API work through any tool that can receive a JSON POST.

Zapier n8n Twilio API docs All platforms

Let a conversation start the workflow

Build the chatbot, point one webhook at Make, and every escalation, question and new visitor lands where your team already works.

Get Started Free