Resources · Make integration

Apifonica Make integrationAutomate Apifonica with Make.

Calls and messages that go out on their own, when something happens in your other tools. The Apifonica Make integration gives you 5 modules: 1 trigger and 4 actions. This page shows what each one does, how to link your account, and how to build a first working scenario.

Try the Apifonica integration on MakeSee the 5 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the Apifonica Make integration do?

The Apifonica Make integration links your Apifonica account to Make so calls and messages can start from events in other apps, without code. You build a scenario, which is the automation itself: a chain of modules, each one a single brick such as a trigger or an action.

A message when a record changes. A new order lands in your shop or a lead fills a form in another app, and Create a Message sends a note through Apifonica with the details mapped from that record. Nobody has to copy anything by hand.

A callback at the right time. When a prospect asks to be called back later, Create a Scheduled Call books the call in Apifonica instead of leaving it on a sticky note. For an immediate ring, Create a Call does the same job right away.

A log of what happened. Watch Communication Results picks up the outcome of your calls and messages so a later module can write them to a sheet or a CRM, where your team can follow up.

The limits are worth knowing upfront. Make's own documentation for Apifonica is marked as limited, because little public information exists about the app, so field details are best discovered in the module itself once your account is connected. Anything the 4 actions do not cover can go through Make an API Call. For a broader view of the platform, read our Make review, and if you are weighing tools, the n8n vs Make comparison lays out the criteria. When a run fails, Make troubleshooting covers the usual causes.

Connect

How do you connect Apifonica to Make?

  1. 01

    Add an Apifonica module

    In your scenario, click the + and search for Apifonica, then pick any of its modules. Click Create a connection. A connection is your Apifonica account linked to Make once, then reused by every Apifonica module you add later.

  2. 02

    Name the connection

    Giving it a name is optional, but it helps once you run more than one account. Something like the team or the line it belongs to makes the right one easy to spot in the dropdown later.

  3. 03

    Authorize and save

    Follow what Make asks for: either approve access on the Apifonica page that opens, or paste the key your Apifonica account gives you. Then click Save, and Make can start reading and acting on your account.

First scenario

Build your first scenario with Apifonica

GoalWhen a new record appears in another app, Make sends a message through Apifonica.

  1. 01

    Create the scenario

    Open the Scenarios page, create a new scenario and click the + to add the first module. Pick the app where your records live, such as a form tool or a store, and choose its watch module.

  2. 02

    Add Create a Message

    Click the + on the right of that first module, search for Apifonica and select Create a Message. Click Create a connection if you have not linked your account yet.

  3. 03

    Map the data

    Fill the fields the module shows. Where it asks for content, click in the field and pick values from the first module, like a name or an order reference, so each message fits its record.

  4. 04

    Test with Run once

    Click Run once. Make runs the scenario a single time and shows the bundles each module received, a bundle being one item passed along, such as one record. Check that the message went out as expected.

  5. 05

    Schedule and switch on

    Click the clock on the first module to set the schedule, every 15 minutes by default, then switch the scenario on. Each module run counts as one operation on your Make plan.

Triggers

What starts an Apifonica scenario

1 module starts a scenario when something happens in Apifonica. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by Apifonica as soon as it happens.

Apifonica1Watch Communication Results

Watch Communication Results

triggerIn the docs only

This trigger brings the outcome of your Apifonica calls and messages into Make, so each result can feed the next step of your scenario. Make's documentation gives no description of it, so its exact output is something to check with a first test.

How it fires
treated here as a scheduled trigger, going by its name: Make checks the app on the scenario's schedule, every 15 minutes by default, with a clock badge on the module.
When to use it
you want results copied to a sheet or a CRM so a colleague can call back anyone who missed the first attempt.
Watch out
run it once before switching the scenario on and read the bundles, so you know which details it actually returns.
Modules

What Apifonica can do in Make

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

Apifonica1

Create a Call

ActionIn the docs only

Starts a phone call through Apifonica straight from a scenario, so an event in another tool turns into a ring without anyone dialing.

When to use it
a high-value lead just submitted a form and you want the call to go out now, not whenever someone notices it.
Watch out
a test with Run once places a real call, so point it at a record you control first.
Apifonica2

Create a Message

ActionIn the docs only

Sends a message through your Apifonica account with content you build from earlier modules, which keeps confirmations and reminders consistent without retyping.

When to use it
an order is confirmed or an appointment is booked in another app and the customer should hear about it right away.
Watch out
Make's documentation lists no fields for this module, so read what the module asks for once the connection exists.
Apifonica3

Create a Scheduled Call

ActionIn the docs only

Books a call in Apifonica for later instead of placing it immediately, so a callback request becomes a planned call rather than a note someone may forget.

When to use it
pick it over Create a Call when the person asked for a specific moment, for example in a form that collects a preferred time.
Watch out
the timing most likely follows the value you map, so test with a record whose time you know.
Apifonica4

Make an API Call

ActionIn the docs only

Reaches any endpoint of the Apifonica API from your scenario, reusing the same connection, for the jobs the other three actions do not cover.

When to use it
you need something Apifonica offers but no listed module handles, and you are comfortable reading the app's API reference.
Watch out
this module assumes you know the endpoint and what it expects, since Make's own documentation for the app is limited.
Need help

Need help automating Apifonica with Make?

A person reads every message.

FAQ

Apifonica and Make: common questions

01Is the Apifonica Make integration free?
Yes, Apifonica is a standard app, so it works from the Free plan. That plan allows 2 active scenarios, a minimum of 15 minutes between scheduled runs, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams and Enterprise) bring the minimum interval down to 1 minute, remove the cap on active scenarios and allow 40 minutes of execution. Usage is counted in operations, one per module run. What Apifonica itself charges for calls or messages is a separate matter that this page does not cover.
02What do you need to connect Apifonica to Make?
An Apifonica account and a Make account. Make's documentation for Apifonica lists no prerequisites and no specific steps, so the generic Make flow applies: add an Apifonica module, click Create a connection, optionally name it, then either approve access on the Apifonica page or paste the key your account gives you, and click Save. The connection is created once and reused by every Apifonica module in all your scenarios. If it fails, recheck the key or access you approved before rebuilding anything.
03Does the Apifonica trigger in Make work in real time?
No, not as far as the available information shows. Watch Communication Results is treated as a scheduled trigger, a type inferred from its name because the documentation does not describe it. Make checks Apifonica on the scenario's schedule, every 15 minutes by default, and never more often than every 15 minutes on the Free plan. Paid plans allow a 1 minute interval. If you need a faster reaction, start the scenario from another app's instant trigger and use the Apifonica actions afterward.
04What if an Apifonica module is missing in Make?
Use Make an API Call. It calls any endpoint of the Apifonica API with the same connection, so you are not limited to the 4 listed actions and 1 trigger. Keep in mind that Make marks its Apifonica documentation as limited, because little public information about the app exists, so plan on the Apifonica API reference for endpoint details. If a result still looks wrong, run the scenario once and read the bundles each module received before changing anything.
05Should you use Make or n8n for Apifonica?
It depends on your criteria rather than on the app. On Make, Apifonica comes with 5 modules: a trigger for communication results, actions to place a call, send a message or schedule a call, and Make an API Call for the rest. Before choosing, check whether n8n offers an Apifonica node that covers the same needs, then compare the two platforms on how you prefer to build, who maintains the scenarios and which other apps you connect. Neither choice changes what the Apifonica API itself allows.
Same platform

Other docs you might need on this stack.

Browse all integrations