Resources · Make integration

ChatterFox Make integrationAutomate ChatterFox with Make.

Can ChatterFox send messages for you when something happens in another app? The ChatterFox Make integration gives you 2 action modules: one sends a message, the other calls the ChatterFox API directly. This guide shows how to link your account and build a first working scenario without code.

Try the ChatterFox integration on MakeSee the 2 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the ChatterFox Make integration do?

The ChatterFox Make integration lets a Make scenario, the automation you build in Make as a chain of bricks, act on your ChatterFox account. Each brick is called a module. ChatterFox offers two, both actions: Send a message and Make an API call. Neither one starts a scenario, so the starting point always comes from another app or from a schedule.

Reply to a new lead. A contact form in another app receives an entry, and Send a message pushes a message out through ChatterFox with the name and details mapped from that entry. The form sits in first position, ChatterFox closes the flow.

Alert a team when a record changes. A deal moves to a new stage in your CRM, a ticket gets a status update, and ChatterFox carries the note to the right people. Here too, the event is watched by the other app and ChatterFox only acts.

Reach what the listed modules skip. Make an API call uses the same connection to call any endpoint of the ChatterFox API, which matters because the official documentation is thin.

Make itself warns that it cannot yet provide complete documentation for ChatterFox, for lack of public information. The module names are all it documents, so check in ChatterFox who a message can reach, then test each module with Run once before trusting it. If you are still weighing tools, the n8n vs Make comparison lays out the criteria, the Make review covers the editor itself, and the Make pricing page explains how operations are counted.

Connect

How do you connect ChatterFox to Make?

  1. 01

    Open the connection window

    Add any ChatterFox module to your scenario and click Create a connection. A connection is your ChatterFox account linked to Make once, then reused by both modules without asking again.

  2. 02

    Name it and authorize Make

    Give the connection a name if you like, handy when you run several ChatterFox accounts. Then approve access on the ChatterFox page that opens, or paste the key ChatterFox gives you, depending on what the window asks for.

  3. 03

    Save and pick your settings

    Click Save. Back in the module, Make can now read what the account exposes, and you fill the remaining fields with values typed by hand or mapped from an earlier module.

First scenario

Your first scenario with ChatterFox

GoalWhen another app records a new event, Make sends a message through ChatterFox with the details of that event.

  1. 01

    Create the scenario

    On the Scenarios page, create a new scenario and click the large +. Pick the app that holds your starting event, such as a form tool or a CRM, and choose its trigger module.

  2. 02

    Add ChatterFox after it

    Click the + on the right of that first module, search for ChatterFox and pick Send a message. Click Create a connection to link your account if it is not done yet.

  3. 03

    Map the message content

    Fill the fields of Send a message. Instead of typing fixed text, click a field and pick values from the first module, so each bundle, meaning each item passed along, produces its own message.

  4. 04

    Test with Run once

    Click Run once, then create a test event in the first app. Open the bubble above each module to read the bundles it received and check that ChatterFox accepted the message.

  5. 05

    Schedule and switch on

    If the first module is a scheduled trigger, open its clock to set the schedule, every 15 minutes by default. Then switch the scenario on. Each module run on one bundle counts as one operation.

Modules

What the ChatterFox modules do

ChatterFox gives you 2 modules. For each one: what it does for you, when to reach for it, and what to watch out for.

ChatterFox1

Make an API call

ActionIn the docs only

Covers anything the ChatterFox API offers that Send a message does not, by calling the endpoint of your choice with the connection you already created. You get back the raw response and map it into the next module.

When to use it
a task your scenario needs has no dedicated module, and ChatterFox documents the API request that performs it.
Watch out
Make's own documentation for ChatterFox is incomplete, so rely on the ChatterFox API reference and test the call with Run once before switching on.
ChatterFox2

Send a message

ActionIn the docs only

Turns an event from another app into a message sent through ChatterFox, filled with data mapped from earlier modules. It is the module most scenarios with ChatterFox end on.

When to use it
a new lead, an order or a status change elsewhere should reach someone through ChatterFox without anyone copying the details by hand.
Watch out
the module runs once per bundle it receives, so a trigger returning ten items sends ten messages and uses ten operations.
Need help

Need help automating ChatterFox with Make?

A person reads every message.

FAQ

ChatterFox and Make: frequent questions

01Is the ChatterFox Make integration free?
Yes, ChatterFox is a standard app in Make, available from the Free plan. That plan keeps 2 scenarios active at once, runs scheduled scenarios at most every 15 minutes, stops each execution after 5 minutes, handles files up to 5 MB and allows 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) lower the interval to 1 minute, lift the limit on active scenarios and allow 40 minutes per execution. Usage is counted in operations, one per module run on one bundle. Any cost of ChatterFox itself is separate and depends on your ChatterFox account.
02What do you need to connect ChatterFox to Make?
A ChatterFox account and a Make account are enough to begin, since Make's documentation lists no specific prerequisite for this app. You add a ChatterFox module, click Create a connection, optionally name it, then authorize Make on the ChatterFox page or paste the key ChatterFox provides, and click Save. The connection is stored once and reused by both modules. Because Make notes that its ChatterFox documentation is limited, keep the ChatterFox account settings at hand in case the window asks for a key you have not generated yet.
03Does the ChatterFox Make integration react in real time?
No, not on its own: ChatterFox has no trigger module in Make, so it cannot start a scenario. The scenario starts elsewhere. Either another app's trigger sits in first position, and the timing then depends on that trigger, scheduled on a clock or instant through a webhook, or you set a schedule on the first module, every 15 minutes by default on a new scenario. ChatterFox then acts inside the run with Send a message or Make an API call. On the Free plan, scheduled runs cannot be closer than 15 minutes apart.
04What if a ChatterFox module is missing in Make?
Use Make an API call. It reaches any endpoint of the ChatterFox API with the connection you already set up, so a task without its own module is still within reach. You will need the ChatterFox API reference to know which request to send, since Make states that it cannot yet provide complete documentation for this app. Test the call with Run once and read the returned bundle before switching the scenario on. If ChatterFox does not expose the action at all, another messaging app in Make may be the better fit.
05Should you use Make or n8n for ChatterFox?
It depends on the tool your team already knows. Make offers ChatterFox as a standard app with two modules, Send a message and Make an API call, usable from the Free plan and set up visually without code. n8n often has a node for the same app, so check its catalog before choosing. There is no performance or pricing verdict to draw between the two from what is documented here. Pick the editor you are comfortable maintaining, and compare criteria side by side before building several scenarios on one of them.
Same platform

Other docs you might need on this stack.

Browse all integrations