Step-by-Step Setup: Creating a Make.com webhook and configuring Awaz.ai to trigger it (with API calls).

Automation Use Cases: Real-world examples (CRM leads → calls, support workflows, Slack notifications, etc.).

Advanced API Usage: Custom workflows, authentication, and security best practices.

Troubleshooting: Common issues and how to fix them.

Initiate AI-driven phone calls when events happen in other apps (e.g. a new CRM lead or a form submission).

Receive instant notifications or data in Make.com whenever Awaz.ai completes a call or updates a contact.

Eliminate manual steps by connecting Awaz.ai’s voice capabilities with your existing tools (CRM, helpdesk, spreadsheets, etc.).

An Awaz.ai account with access to API credentials (API key). Find your Awaz API key in your Awaz.ai dashboard (transcript (3).txt) (you’ll need this for authenticated API calls).

A Make.com account to build your scenario (free plan is usually sufficient for testing).

Basic familiarity with Make.com’s scenario editor and Awaz.ai’s concepts (agents, contacts, call campaigns).

A. Using Awaz.ai built-in webhooks or integrations: Awaz.ai has native integrations (e.g., Zapier) and likely allows webhooks for certain events. For instance, Awaz.ai’s Zapier integration can trigger when a call is finished or when an agent initiates a call (transcript (3).txt). Check Awaz.ai’s settings or documentation for any “Webhooks” or “Integrations” section where you can input a callback URL. If available, you would paste the Make.com webhook URL there and select the event that should trigger it (e.g., call completed or new call outcome). This way, whenever that event occurs, Awaz will POST the data (call details, contact info, outcome, etc.) to your Make webhook automatically.

B. Using Awaz.ai API via custom calls: If Awaz.ai doesn’t directly support outgoing webhooks, you can achieve the same result by calling Awaz.ai’s API from within Make (or another service) on a schedule or when polled. For example, you could set up a scheduled Make scenario that periodically calls an Awaz API endpoint to fetch recent call results, then triggers subsequent modules if a new completed call is found. However, a more immediate approach is to use a small script or cloud function (or even an Awaz.ai workflow action, if supported) that calls the Make webhook URL as soon as an event occurs. Awaz.ai’s API documentation (Building an AI Assistant for VIP Event Registrations) will be your guide here – look for endpoints related to calls or events. Awaz likely provides an endpoint like “Get recent calls” or even a setting to push events. Using those, you’d POST to the Make URL with relevant data.

Add or Update Contact: This API endpoint (refer to Awaz documentation for the URL and format) lets you send a contact’s details (name, phone, email, etc.) to Awaz. In Awaz, contacts are usually stored in lists. By adding a contact to a specific list that’s tied to a call campaign, you can automatically queue that contact for a call. In our example, when a new lead comes in, we’ll POST the lead’s data to Awaz via the API. Awaz will then add it to the contacts list (or update if it exists). If that list is associated with an active outbound campaign, the AI agent will immediately (or as scheduled) dial that contact (transcript (3).txt). (In Zapier, this was done by choosing “Add or Update Contact” which, when the contact was added to the “Closed Won” campaign list, triggered the AI call automatically (transcript (3).txt).)
​
​

Make a Call: This endpoint likely triggers an immediate outbound call via Awaz.ai’s agent. You would provide the phone number (and possibly agent or campaign ID). This is useful if you want to directly dial a number on-demand rather than adding to a campaign list. In Make, you’d use an HTTP POST module, set the URL to Awaz’s “make call” API endpoint, and include JSON like { "agent_id": "...", "phone": "...", "contact_name": "..." } as required by the API. The API key must be included (usually as an Authorization: Bearer <API_KEY> header or x-api-key header – check Awaz’s API docs for the exact auth mechanism).
​

Test triggering a call: Simulate a real use case. For instance, add a dummy lead in your CRM (or whatever event you set up) to ensure Make successfully calls Awaz’s API. In Awaz.ai, check that the contact appears in the appropriate list or that a call was initiated. You should see the AI agent calling the test number (use a number you can answer). Confirm that the call goes through. This tests the Make → Awaz direction.
​
​

Test the webhook callback: Now let the Awaz.ai call complete and trigger the outcome. If you set the event for “call finished” with outcome, you might need to speak in a way that leads the AI to mark the call as successful (or you can manually end the call and mark outcome in Awaz’s dashboard if possible for testing). When the call finishes, Awaz should send a webhook POST to the Make URL. Make’s scenario (if listening or active) should receive the data. In the Make scenario editor, you’ll see the webhook module light up with the incoming data. If it’s the first time, Make will capture the data structure. You can then map that data to other modules (like Slack or Google Sheets) in your scenario.
​
​

Verify data: Check the output in Make. You should see fields like contact name, phone, agent name, call status, maybe call recording URL or transcript text, etc. (Awaz provides a rich analysis of the call including transcript and outcome reason (transcript (3).txt), which should be part of the payload or accessible via a follow-up API call). Ensure that the data you need (e.g., “call outcome = interested” or “transcript text”) is present. If not, you might call Awaz’s API for more details using the call ID from the webhook.
​
​

End-to-end run: Finally, turn on the scenario and do a full test: e.g., Add a new lead → Make triggers Awaz call → Awaz calls your phone (AI speaks) → you respond to simulate an outcome → Awaz posts back to Make webhook → Make logs the call info and posts a Slack message. This end-to-end test will confirm everything is working.
​
​

Salesforce/Zoho CRM Trigger: Use Make’s Salesforce, Zoho, HubSpot (or any CRM) module to watch for new leads or contacts. Many CRMs have native Make triggers or you can use a webhook from the CRM. For example, a “New Lead in Salesforce” event triggers the scenario.

Awaz Add Contact Action: Pass the lead’s details to Awaz via the Add Contact API. Include the lead’s name and phone number (and any other fields Awaz might accept, like email or custom attributes). Assign it to the appropriate Awaz campaign or agent. This can be done by hitting Awaz’s endpoint (e.g., POST /contacts) with JSON data.
​
​

Awaz Initiates Call: Once Awaz has the new contact, its AI agent can automatically place an outbound call (if configured to auto-dial new contacts in that list) (transcript (3).txt). The AI voice assistant will call the lead, introduce your product or gather information, etc., as per your agent script. Awaz.ai lets you use multiple AI agents to handle these voice calls simultaneously in real-time conversations (Awaz.ai Webhooks by Zapier Integration - Quick Connect - Zapier), ensuring scalability even if many leads pour in.
​
​

Follow-up in Make: After the call, Awaz will send the call outcome to the Make webhook. Based on the outcome, your scenario can branch: if the lead was interested, you might create a follow-up task in the CRM or alert a sales rep; if not interested, perhaps update the lead status in the CRM. All this can be automated with Make.

AI-Powered Hotline: Set up Awaz.ai to answer inbound support calls (using an AI agent that can handle common questions or gather details). When an inbound call comes in and is completed, Awaz can send the transcript and call info via the webhook. Make can then take that data to create a support ticket in your helpdesk (e.g., Zendesk, Freshdesk) or send an email to your support team with the call summary.
​
​

Follow-up on Support Tickets: Conversely, when a support ticket is created (say a customer emails a question), you could have an Awaz.ai agent automatically place an outbound call to the customer acknowledging the request or providing initial guidance. For example, a Make scenario watches your helpdesk for new high-priority tickets, then uses Awaz’s API to initiate a call to the customer. The AI agent might say “We’ve received your request and are working on it. Press 1 if you’d like to speak to an agent.” This blends AI with human support seamlessly.
​

Multi-channel Notifications: Not all customers may answer the phone. Awaz.ai can also send SMS or WhatsApp messages (it has WhatsApp integration built-in (transcript (3).txt)). Through Make, you can coordinate these channels: e.g., if call goes to voicemail, trigger an SMS follow-up via Twilio or Awaz’s SMS API.

Logging and Analysis: Every support call handled by Awaz can be logged to a Google Sheet or database via Make. This creates a searchable archive of issues and resolutions. Awaz provides the full transcript, sentiment analysis, and outcome reason for each call (transcript (3).txt), which is incredibly useful for QA and training. You can use Make to store these details or even forward them to an analytics tool.

Slack Notifications: Using Make’s Slack modules, you can send a message to a Slack channel or user whenever an Awaz call finishes. For example, post: “:telephone_receiver: Call completed – Lead John Doe expressed interest in Product X. Outcome: Interested. Summary: Interested in pricing, asked for a follow-up.”. This keeps your team in the loop in real-time. Include key info like call outcome, any important notes or even the call recording link. Your Make scenario can compose a Slack message using fields from the Awaz webhook payload (name, phone, outcome, etc.). If you have the transcript text, you could even attach it or summarize it. Slack messages can be formatted with markdown for readability.

Google Sheets Logging: For record-keeping, have Make append a row to a Google Sheet for each call. Columns could be: Timestamp, Contact Name, Phone, Agent Name, Call Outcome, Call Duration, Notes/Transcript Summary. Over time, this becomes a call log spreadsheet. It’s great for tracking performance of your AI calls and can be shared with stakeholders who prefer Excel/Sheets.
​
​

Airtable or Database Updates: Similarly, you might use Airtable to store richer data. Each Awaz call can create a new Airtable record. Because Airtable is like a spreadsheet-database hybrid, you can build views and filters (e.g., all calls where outcome = interested but no appointment set). Make’s Airtable integration makes this easy – map fields from Awaz’s data to your Airtable base.

Email Summaries: If some stakeholders prefer email, Make can send an email with the call summary. For instance, a daily digest of all Awaz calls or immediate email to a salesperson for their lead’s call. Using Make’s email module or Gmail integration, you can craft these emails with dynamic content.

Awaz.ai API Endpoints: Consult the [Awaz.ai API documentation] (Building an AI Assistant for VIP Event Registrations) (on Postman) for a full list of endpoints. Key ones likely include endpoints for managing Contacts, Calls, Campaigns, and Agents. For example, there may be endpoints like POST /api/v1/contacts (to create a contact), POST /api/v1/calls (to initiate a call), GET /api/v1/calls/{id} (to retrieve call details or transcript), etc. Knowing these allows you to extend your integration. Suppose you want to retrieve the full call transcript after a call – there might be an API method for that if it’s not already in the webhook data. You could use a Make HTTP module to GET /calls/{call_id}/transcript after receiving the webhook (using the call_id from the webhook) and then use that text for something (like sentiment analysis or feeding into a CRM note).
​
​

Authentication: Awaz.ai likely uses API Key or Bearer token authentication for API calls. As noted earlier, your API key from the Awaz dashboard is required. Typically, you include it in an HTTP Authorization header. For example, Awaz might expect Authorization: Bearer <YOUR_API_KEY> or a custom header like x-api-key: <YOUR_KEY>. The API docs should specify this. In Make.com’s HTTP module, you can add headers in the request – be sure to include the auth header exactly as required. Keep this key secret. In Make, when you paste it into a header field, it will be masked after saving. Avoid exposing it in plain text within any data stores or logs. If multiple scenarios need the same auth, consider using Make’s [Connections] or store the key in a confidential variable.
​
​

Handling Data Formats: Awaz’s API will return data in JSON format. Make can automatically parse JSON to variables if you use the JSON parse tool or if the HTTP module is set to parse it. When sending data to Awaz, ensure you format the JSON exactly as expected. For instance, phone numbers might need E.164 format (e.g., “+15551234567”). Strings might need specific encoding if they contain special characters. Always test with sample data first using tools like Postman or the Make HTTP module in preview mode.
​
​

Error Handling: Implement checks for API call success. Awaz’s API will return HTTP status codes (200 for success, 4xx for client errors, 5xx for server errors). In Make, you can evaluate the HTTP response; if it’s not 200, you can route to an error handler route (Make allows routers or separate paths for error handling). For example, if adding a contact fails (maybe due to a duplicate or validation issue), you could log that error or notify an admin. Common errors might be: invalid API key (401 Unauthorized), missing required fields (400 Bad Request), or rate limit exceeded. If you anticipate high volume, check Awaz’s rate limit policy in the docs and use Make’s iterator or throttler to pace API calls if needed.
​
​

Security Best Practices: Aside from keeping API keys safe, consider the data privacy. Call transcripts might contain sensitive info (personal data, etc.). Ensure that wherever you send this data (Slack, Sheets, etc.), it’s allowed by your privacy policy and data security standards. Make.com is GDPR-compliant and secure, but you should still avoid oversharing sensitive call content in public channels. If using webhooks, prefer HTTPS (Make’s are HTTPS by default). If your workflow involves any public-facing endpoints, use verification tokens. Also, regularly rotate your Awaz API key if possible and remove it if someone who had access leaves your organization.
​
​

Combining with Other APIs: The real power of Make is using multiple APIs together. Awaz.ai can be just one part of a larger automation. For example, you might integrate Awaz with an NLP API: after a call, send the transcript to an AI like Google Cloud Language API for sentiment analysis, then log the sentiment score. Or integrate with a text-to-speech service if you want to generate a voice file… though Awaz has TTS built-in, so likely not needed. The key is Awaz’s API gives you voice call capabilities, which you can enrich by connecting to any other API in Make’s ecosystem.
​
​

Make.com Webhook Not Triggering: If you’ve sent events from Awaz but your Make scenario isn’t firing, first verify that Awaz actually made the HTTP request. Check Awaz.ai’s logs or dashboard if it shows webhook deliveries (some services log whether the webhook was sent and if it succeeded). Also, ensure your Make scenario is enabled (or was listening for the first webhook to determine the data structure). One trick: open the webhook URL in a browser – you should see a {} or some acknowledgment if Make is set up. If you get an error page, the URL might be incorrect. Copy it exactly from Make (it’s long and case-sensitive). If behind a firewall, ensure no network issues (Make’s webhooks are cloud-hosted, so generally reachable).
​
​

Authentication Errors (401/403): If Make’s HTTP calls to Awaz return 401 Unauthorized, your API key is likely wrong or missing. Re-check the API key in Awaz’s dashboard. Did you include the correct header in the HTTP module? (For example, if Awaz expects Authorization: Bearer, make sure you have that format). Also confirm you have the right base URL (maybe Awaz’s API base URL is something like https://api.awaz.ai/v1 – using the wrong domain or path will fail). Refer to Awaz’s auth info in the documentation to ensure proper usage of the key or token (transcript (3).txt).
​
​

Incorrect Payload/Field Names: If calls or contact creations are not working, the JSON you send might be malformed or have wrong field names. Double-check the API docs for exact field names. For example, maybe it’s "phoneNumber" vs "phone" or expecting an array of contacts vs single object. Use Make’s Logger or output the response from Awaz’s API; often, the error message from Awaz will tell you what’s wrong (e.g., “Missing required field: phone”). You can use a tool like Postman with the same API to see if your request should be adjusted.
​
​

Duplicate Triggers or Data: If you find that the scenario runs twice for one event or you get duplicate entries in Sheets, etc., check that you don’t have multiple triggers set for the same thing. Also, sometimes Make might be catching old data if you left the webhook module in listening mode and then didn’t disable it. Once the data structure is captured, uncheck the “Determine data structure” unless you intentionally want to recapture. In Make, each execution will have an Execution ID you can trace; use the Make history to see why it might have looped. Perhaps your scenario is configured to reinject data. Add filters to ensure one execution per event (like filter by a unique call ID that you mark as processed, if necessary).
​
​

Awaz Webhook Payload Issues: If the data Awaz sends is not in the format you expect, you can adjust in Make. Sometimes the webhook might send a nested JSON or an array. Use Make’s JSON parsing or the built-in feature to parse the payload. If Awaz sends a lot of data and you only need some, just extract those fields in Make. If fields are missing, you may need to call another API to get them. For instance, maybe the webhook gives only a call ID and you have to call Awaz’s API for full details. Recognizing this, you can build a step: after the webhook trigger, add an HTTP GET to Awaz API for that call ID, then proceed. This two-step approach ensures you have all info.
​
​

Timing Issues: If you trigger an Awaz call via API and immediately expect a webhook back, note there might be a delay – the call has to actually occur. If testing, you might wonder “why didn’t I get a webhook?” perhaps because the call is still in progress. To troubleshoot, try using a short call or answering and hanging up quickly to generate the event. Also, ensure that your Awaz trigger is set for the right event – e.g., call finished (and not something else like agent started call, unless that’s what you want). The transcript and outcome are only available after the call finishes successfully (transcript (3).txt), so triggering too early won’t have that info.
​
​

Slack Message Formatting: If your Slack notifications look weird (e.g., JSON appearing as text), remember to format the message. Make allows you to compose a Slack message with markdown. Test a sample message in Slack to see how it renders. You might also hit Slack’s rate limits if you send too many messages too quickly (unlikely in our scenario, but possible in a loop). If so, consider batching some notifications or adding slight delays.
​
​

Google Sheets/Airtable Quirks: When writing to Google Sheets, make sure the sheet is shared with your Make Google connection. Also, inserting many rows quickly can sometimes cause issues due to Google API limits. Use Make’s Google Sheets “Add row” module properly and maybe a 1-second delay in between if doing high volume. For Airtable, ensure the base and table IDs are correct and the fields exactly match (Airtable is case-sensitive with field names).
​
​

Awaz Call Quality or Behavior: Occasionally, the “troubleshooting” needed isn’t technical integration but the AI call itself. If the Awaz AI agent isn’t responding correctly or the outcome is not being set when it should, you might need to tweak the Awaz agent script or settings. For example, ensure the agent’s Objective is clearly causing an Outcome when appropriate (as mentioned earlier, Awaz uses the agent’s objective to determine call success (transcript (3).txt)). If you expected an outcome but got a different status like “Pickup” or “No Outcome”, the AI might not have gotten the confirmation it needed. This is more on Awaz’s side – refine your conversation flow or conditions. Once that’s fixed, the integration will naturally work more smoothly because the correct events will fire.
​
​

Contact Already Exists (Update vs Create): If you use “Add or Update Contact” repeatedly for the same contact (e.g., same phone number), Awaz might just update it and perhaps not trigger a new call if the campaign logic avoids recalling the same lead. In testing, you might add the same test lead twice and wonder why the second time no call. It could be because Awaz saw it as a duplicate and ignored it for calling. Check Awaz’s documentation on how it handles duplicate contacts. A workaround is to delete test contacts in Awaz between tests or use unique dummy numbers.
​
​