https://retellai.com/?utm_source=discord&utm_medium=seo logo
Powered by
Hi how can i do a callback for example someone say...
# ❓・ai-evy-support
z
@AI Evy Hi how can i do a callback for example someone say to my ai caller call me back tommorow, next week, later and etc how can i do that i use sympana connector to connect ghl and retellai but if retell can get all that info and just call them automatically thats great bcs what i only need in ghl is the post call extraction
a
Thanks for tagging me @Zai. I'll look through relevant sources and get back to you shortly.
### Answer Based on the available sources, here's how you can handle callback scheduling with Retell AI: Extract Callback Information Using Post-Call Analysis You can use Retell AI's Post-Call Analysis feature to automatically extract callback requests from conversations [(1) ]() [(2) ]() . This feature analyzes customer conversations after they end and can extract various types of data [(1) ]() . You can configure custom analysis categories to capture callback information [(1) ]() [(2) ]() : - Text type: Extract specific callback timing phrases like "tomorrow", "next week", "later" - Boolean type: Determine if a callback was requested (yes/no) - Selector type: Categorize callback timeframes from predefined options Automate Callbacks Using Batch Calling Once you've extracted the callback information, you can use Retell AI's Batch Dialer to schedule the callbacks [(3) ]() . The Batch Dialer supports: - **Send Now**: Dispatch calls immediately - **Scheduled Time**: Automate call timing for precision outreach You can upload contact lists and schedule when calls should be made . Integration Approach To connect this workflow: 1. Configure Post-Call Analysis to extract callback requests and timing [(1) ]() [(2) ]() 2. Use webhooks to receive the analysis results once a call ends [(2) ]() 3. Process
the extracted callback data and schedule batch calls accordingly [(3) ]() The Post-Call Analysis results are typically available within seconds of the call ending [(2) ]() , and you can access them through webhooks or APIs to integrate with your workflows . **Note**: Retell AI doesn't currently have native automatic callback scheduling based on extracted conversation data. You'll need to build the logic between Post-Call Analysis extraction and Batch Call scheduling, which your Sympana connector could potentially handle by receiving webhook data from Retell and triggering scheduled batch calls.
​ To learn more, see the sources I considered: [[1] Post Call Analysis Overview](https://docs.retellai.com/features/post-call-analysis-overview) [[2] Unlock Insights with Post-Call Analysis | Retell AI](https://www.retellai.com/features/post-call-analysis) [[3] Streamline Calls with Retell AI’s Batch Dialer | Retell AI](https://www.retellai.com/blog/boost-operation-efficiency-with-retell-ais-batch-calling) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy tell me step by step what softwares i can use and is go high level still need for callbacks or not
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on the available sources, here's a step-by-step approach for handling callbacks: Step-by-Step Software Setup: 1. Retell AI Dashboard - Configure Post-Call Analysis to extract callback information [(1) ]() - Set up custom analysis categories (Boolean, Text, or Selector types) to capture callback requests - These categories can identify when someone requests "call me tomorrow," "next week," etc. 2. Webhook Receiver - Receive analysis results [(2) ]() - Configure webhooks to get notified when call analysis is complete - The webhook payload includes the 
call_analysis
field with your custom extracted data 3. Retell AI Batch Dialer - Schedule the callback [(3) ]() - Upload contact lists via CSV (up to 50 MB) - Choose "Send Now" for immediate calls or "Schedule" for future timing - Costs just $0.005 per dial Do You Still Need GoHighLevel? Based on the sources, you still need some middleware (which could be GHL or another automation tool) because: - Retell AI extracts the callback data through Post-Call Analysis [(2) ]() [(1) ]() - Retell AI can make the scheduled calls via Batch Dialer [(3) ]() - However, Retell AI doesn't automatically connect these two features - you need something to receive the webhook data and trigger the batch call [(2) ]() [(3) ](
-with-retell-ais-batch-calling) Your Sympana Connector for GHL could handle this middle step by receiving Retell's 
call_analyzed
webhook and then creating scheduled batch calls [(4) ]() . Alternatively, you could build custom middleware without GHL if you prefer. The key gap is that automatic callback scheduling based on conversation content isn't natively built into Retell AI - you need integration logic between the analysis output and batch calling input.
​ To learn more, see the sources I considered: [[1] Post Call Analysis Overview](https://docs.retellai.com/features/post-call-analysis-overview) [[2] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[3] Streamline Calls with Retell AI’s Batch Dialer | Retell AI](https://www.retellai.com/blog/boost-operation-efficiency-with-retell-ais-batch-calling) [[4] Sympana Connector | Retell AI APP Partner](https://www.retellai.com/app-partner/sympana) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy i dont get it where should the webhook reciever go ? into ghl? into n8n? into make,com? or into retellai itself?
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer The webhook receiver should go outside of Retell AI - into tools like GHL, n8n, or Make.com [(1) ]() [(2) ]() . Here's how it works: 1. **In Retell AI Dashboard**: You configure your webhook URL pointing to your external automation tool [(2) ]() 2. Your External Tool (GHL/n8n/Make.com) : This receives the POST requests from Retell AI [(1) ]() [(2) ]() 3. **Retell AI**: Sends the webhook data TO your external tool when events occur [(2) ]() Specifically for your setup: - **Webhook URL Configuration**: Set up in Retell AI dashboard's webhooks tab (for account-level) or in agent settings (for agent-level) - **Webhook Destination**: Points to your GHL, n8n, or Make.com endpoint URL - **What Retell Sends**: POST requests with 
call_analyzed
event type containing your Post-Call Analysis data [(1) ]() [(2) ]() Example Flow:
Copy code
Retell AI → (sends POST) → Your Make.com/n8n/GHL webhook URL → (processes data) → Triggers next action
The webhook receiver is essentially a URL endpoint in your automation platform that "listens" for Retell AI's POST requests [(2) ]() . You give Retell AI this URL, and Retell automatically sends data there when calls end and are analyzed [(1) ]() [(2) ]() . For Make.com specifically, community members have successfully used it to receive Post-Call Analysis data, though you need to filter for the 
call_analyzed
webhook event (the third webhook sent per call) [(3) ]() .
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Webhook Overview](https://docs.retellai.com/features/webhook-overview) [[3] Post Call Analysis Data not able to select in Make.](https://discord.com/channels/1186424376300679209/1425229235567460423) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy what exactly should i add into post request ? and where should it go hows the system work ?
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer You don't add anything to the POST request - Retell AI sends it TO you automatically [(1) ]() . Here's how the system works: The Flow: 1. Retell AI makes the POST request (not you) 2. Your automation tool receives it (GHL/Make.com/n8n) 3. You process the data that Retell sent What Retell AI Sends: When a call is analyzed, Retell AI automatically POSTs this payload to your webhook URL :
Copy code
json
{
 "event_type": "call_analyzed",
 "call": {
 // Call object with call_analysis field populated
 }
}
What's Inside the Payload: The 
call_analysis
object contains your Post-Call Analysis data : - `call_summary`: Text summary of the call [(2) ]() - `user_sentiment`: Sentiment analysis - `call_successful`: Boolean for success status - `custom_analysis_data`: Your custom extraction fields Setup Steps: 1. **In Make.com/n8n/GHL**: Create a webhook trigger and copy the webhook URL [(1) ]() 2. **In Retell AI Dashboard**: Paste that URL into your webhook configuration 3. **Subscribe to 
call_analyzed
event**: This is the third webhook that contains Post-Call Analysis data [(3) ]() 4. **Retell AI handles the rest**: After each call ends and is analyzed, Retell automatically POSTs the data to your URL [(1) ]() Important Note: Post-Call Analysis variables are only sent in the 
call_analyzed
webhook, not in 
call_started
or 
call_ended
webhooks [(3) ]() . Make sure you're listening for the correct event type. You're receiving data, not sending it. Your automation tool just needs to be ready to accept Retell's POST requests [(1) ]() .
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] List Calls](https://docs.retellai.com/api-references/list-calls) [[3] Webhook not delivering Post-Call Analysis variables](https://discord.com/channels/1186424376300679209/1369886917893820457) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy heres the process of my system 1. send sms through ghl if they dont respond 2. it goes through retellai calling using sympana connector to call 3rd after the call we get post call analysis 4 configure if they need to callback 5 if yes we call back. Problem is in 3 upto 5
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
z
@AI Evy heres the process of my system send sms through ghl if they dont respond 2. it goes through retellai calling using sympana connector to call 3rd after the call we get post call analysis 4 configure if they need to callback 5 if yes we call back. Problem is in 3 upto 5
a
### Answer Based on your workflow, the issue at step 3 (getting Post-Call Analysis) can be resolved through three methods [(1) ]() : Method 1: Dashboard Access View analysis results directly in your Retell AI dashboard's history tab . The defined analysis categories appear in the "Conversation Analysis" column . *Method 2: Webhook (Recommended for Your Automation) * Receive real-time notifications when call analysis completes . The webhook payload includes :
Copy code
json
{
 "event_type": "call_analyzed",
 "call": {
 // Call object with call_analysis field populated
 }
}
To set up webhooks, configure them in your Retell AI dashboard . The 
call_analysis
object contains [(2) ]() [(3) ]() : - `call_summary`: Text summary of the conversation - `user_sentiment`: Sentiment analysis - `call_successful`: Boolean for success status - `custom_analysis_data`: Your custom extraction fields Method 3: Get Call API Retrieve analysis results programmatically using the Get Call API [(1) ]() [(3) ]() . The response includes the 
call_analysis
field with all analysis results . For Your Specific Problem: Since you're using Sympana Connector with GHL, you should: 1. Configure the 
call_analyzed
webhook in Retell AI to point to your GHL or middleware endpoint [(1) ]() 2. Ensure your webhook is subscribed to the 
call_analyzed
event type (this is the third webhook sent per call) [(4) ]() 3. Process the 
custom_analysis_data
field to check if callback is needed [(1) ]() [(2) ]() 4. Trigger your callback workflow based on that data Important Note: Post-Call Analysis fields are not populated for calls that were not connected or where no conversation took place [(1) ]() . Always check whether the field exists before using it .
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] List Calls](https://docs.retellai.com/api-references/list-calls) [[3] Get Call](https://docs.retellai.com/api-references/get-call) [[4] Discord message from @truthseeker28 on 2025-02-25](https://discord.com/channels/1186424376300679209/1186462578310910112/1343975428200857742) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy s the process of my system send sms through ghl if they dont respond 2. it goes through retellai calling using sympana connector to call 3rd after the call we get post call analysis 4 configure if they need to callback 5 if yes we call back. Problem is in 3 upto 5
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on your workflow, here's how to solve steps 3-5: Step 3: Configure Post-Call Analysis to Extract Callback Data [(1) ]() [(2) ]() In your Retell AI agent settings, set up custom Post-Call Analysis fields to detect callback requests : - **Boolean type**: "Does customer want a callback?" (True/False) - **Text type**: Extract when they want the callback ("tomorrow", "next week", etc.) - **Selector type**: Categorize timing options from predefined choices Step 4: Receive the Analysis Data via Webhook [(3) ]() Configure a webhook in Retell AI dashboard to send the 
call_analyzed
event to your GHL or middleware endpoint . The webhook payload will be :
Copy code
json
{
 "event_type": "call_analyzed",
 "call": {
 // Call object with call_analysis field populated
 }
}
**Critical Detail**: The 
call_analyzed
webhook is the third webhook sent per call [(4) ]() [(5) ]() . The Post-Call Analysis data (
custom_analysis_data
) only appears in this specific webhook event, not in 
call_started
or 
call_ended
. Step 5: Trigger Callback Based on Analysis Once you receive the 
call_analyzed
webhook [(3) ]() : 1. Check the 
custom_analysis_data
field for your callback indicators [(3) ]() [(6) ]() 2. If callback is needed, use Retell AI's Batch Dialer to schedule the callback call [(7) ]() 3. Upload the contact via CSV or API and choose "Schedule" to set the callback time **Important Note**: Post-Call Analysis fields are not populated for calls that were not connected or where no conversation took place [(3) ]() [(1) ]() . Always verify the field exists before using it . Common Issue with Make.com/GHL Integration [(4) ]() : When testing in Make.com, you need to run the scenario with unprocessed data after making a test call . The 
custom_analysis_data
variables only become selectable after you've processed the 
call_analyzed
event at least once .
​ To learn more, see the sources I considered: [[1] Post Call Analysis Overview](https://docs.retellai.com/features/post-call-analysis-overview) [[2] Unlock Insights with Post-Call Analysis | Retell AI](https://www.retellai.com/features/post-call-analysis) [[3] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[4] Post Call Analysis Data not able to select in Make.](https://discord.com/channels/1186424376300679209/1425229235567460423) [[5] Discord message from @keshav3 on 2025-01-30](https://discord.com/channels/1186424376300679209/1186462578310910112/1334444968156332126) [[6] List Calls](https://docs.retellai.com/api-references/list-calls) [[7] Streamline Calls with Retell AI’s Batch Dialer | Retell AI](https://www.retellai.com/blog/boost-operation-efficiency-with-retell-ais-batch-calling) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy question bcs my ghl has a inbound webhook and i created a postwebhook can the inbound in ghl get info from thepost call analysis if its not inside the post webhook i created in retellai like bcs you can create you own function for the webhook right this is my current webhook from function { "type": "object", "properties": { "bedrooms": { "type": "string", "description": "The number of bedrooms in the property." }, "property_condition": { "type": "string", "description": "The overall condition of the property." }, "roof_condition": { "type": "string", "description": "The current condition of the roof." }, "occupancy": { "type": "string", "description": "The occupancy status of the property." }, "motivation_to_sell": { "type": "string", "description": "The seller's motivation or reason for selling." }, "ideal_close_date": { "type": "string", "description": "The seller's ideal closing date for the deal." }, "bathrooms": { "type": "string", "description": "The number of bathrooms in the property." }, "asking_price": { "type": "string", "description": "The seller's asking price for the property." }, "callback_requested": { "type": "boolean", "description": "Whether the user requested a callback." }, "callback_time": { "type": "string", "description": "The time the user wants to be called back. Must be in ISO format if available." } }, "required": [ "bathrooms", "bedrooms", "roof_condition", "occupancy", "motivation_to_sell", "asking_price", "property_condition", "ideal_close_date", "callback_requested" ] }
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_id": "...",
    "call_analysis": {
      "call_summary": "...",
      "user_sentiment": "...",
      "call_successful": true,
      "custom_analysis_data": {
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
Your custom function schema and Post-Call Analysis are two separate systems that can work together - one for real-time data during calls, one for analyzed data after calls complete [(4) ]() [(1) ]() [(2) ]() [(3) ]() .
analysis-consumption) - Define custom analysis fields for the data you want extracted - These fields will appear in 
custom_analysis_data
[(4) ]() [(5) ]() [(3) ]() 2. Set Up the 
call_analyzed
Webhook [(4) ]() - Point it to your GHL inbound webhook URL - Subscribe to the 
call_analyzed
event type 3. **GHL Will Receive Both**: - Real-time data from your custom function (during call) [(1) ]() [(2) ]() [(3) ]() - Post-Call Analysis data from 
call_analyzed
webhook (after call) [(4) ]() [(5) ]() [(3) ]() The 
call_analyzed
Webhook Payload Structure: [(4) ]()
### Answer Your confusion is understandable - you're mixing up two different webhook systems. The Schema You Shared is for a Custom Function (Tool) , NOT Post-Call Analysis That JSON schema you provided defines a custom function/tool that your agent can call during the conversation to send data to GHL in real-time [(1) ]() [(2) ]() [(3) ]() . This is separate from Post-Call Analysis. Two Different Data Extraction Methods: *1. Custom Function/Tool (What You Currently Have) * - Happens during the call - Your agent invokes this function to send data to your GHL webhook endpoint immediately - The schema you shared defines what data gets sent to GHL when the function is called *2. Post-Call Analysis (What You Need to Add) * - Happens after the call ends [(4) ]() [(5) ]() [(3) ]() - Retell AI analyzes the conversation and extracts data based on your configured analysis categories - Sent via the 
call_analyzed
webhook event [(4) ]() - Contains the 
call_analysis
object with 
custom_analysis_data
[(4) ]() [(5) ]() [(3) ]() To Get Post-Call Analysis Data in GHL: Your GHL inbound webhook can receive Post-Call Analysis data, but you need to: 1. Configure Post-Call Analysis in Retell AI (separate from your function schema) [(4) ](
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy is my webhook i sent good
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Your webhook schema looks good for a custom function/tool, but it's not the same as configuring Post-Call Analysis [(1) ]() [(2) ]() . What Your Schema Does: The JSON schema you shared defines a custom function that your agent can invoke during the conversation to send data to your GHL webhook in real-time . This includes fields like 
bedrooms
, 
property_condition
, 
callback_requested
, etc. What's Missing for Post-Call Analysis: To get Post-Call Analysis data (which is sent after the call via the 
call_analyzed
webhook) , you need to separately configure Post-Call Analysis categories in your Retell AI agent settings [(3) ]() [(4) ]() . The 
call_analyzed
Webhook Payload Structure: When Retell AI sends the 
call_analyzed
event to your GHL inbound webhook, it will have this structure [(3) ]() :
Copy code
json
{
  "event": "call_analyzed",
  "call": {
    "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
    "call_analysis": {
      "call_summary": "...",
      "user_sentiment": "Positive",
      "call_successful": true,
      "custom_analysis_data": {}
    }
  }
}
Your 
custom_analysis_data
field will contain the Post-Call Analysis results you configure separately from your function schema [(5) ]() [(2) ]() . Bottom Line: - Your webhook schema is good for real-time data extraction during calls [(1) ]() [(2) ]() - For Post-Call Analysis data after calls, you need to configure analysis categories in Retell AI dashboard separately [(3) ]() [(4) ]() - Both can send data to the same GHL inbound webhook, but they arrive at different times and in different payload structures [(3) ]() [(1) ]() [(2) ]()
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy how to use post call extraction from retellai to ghl
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer To send Post-Call Analysis data from Retell AI to GHL, follow these steps: Step 1: Configure Post-Call Analysis Categories in Retell AI [(1) ]() [(2) ]() Go to your agent detail page in Retell AI dashboard and click the "Post-Call Analysis" tab [(2) ]() . Create custom analysis categories for the data you want to extract [(1) ]() [(2) ]() : - **Boolean**: For yes/no questions (e.g., "callback_requested") - **Text**: For detailed information (e.g., "callback_time", "property_notes") - **Number**: For numerical values (e.g., "asking_price") - **Selector**: For predefined options (e.g., "property_condition") Step 2: Set Up Webhook in Retell AI [(1) ]() In your Retell AI dashboard, configure a webhook pointing to your GHL inbound webhook URL . Make sure to subscribe to the 
call_analyzed
event type . Step 3: Webhook Payload Structure When a call ends and is analyzed, Retell AI will automatically POST this payload to your GHL webhook :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    // Call object with call_analysis field populated
  }
}
The 
call_analysis
object contains [(1) ]() [(3) ]() : - `call_summary`: Text summary of the call - `user_sentiment`: Sentiment analysis - `call_successful`: Boolean for success status - `custom_analysis_data`: Your custom extraction fields Step 4: Receive Data in GHL Your GHL inbound webhook will receive the 
call_analyzed
event automatically after each call completes [(1) ]() . The analysis results are typically available within seconds of the call ending [(2) ]() . Important Notes: - Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place [(1) ]() - Always check whether the field exists before using it - The 
call_analyzed
webhook is separate from any custom function webhooks you may have configured
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Unlock Insights with Post-Call Analysis | Retell AI](https://www.retellai.com/features/post-call-analysis) [[3] List Calls](https://docs.retellai.com/api-references/list-calls) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
create me the fullwebhook code tell me what you need
@AI Evy create me the fullwebhook code tell me what you need
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer To create a webhook receiver for Retell AI's 
call_analyzed
event, I need to know: 1. What platform/language are you using? (Node.js, Python, or another language) 2. What do you want to do with the data? (Send to GHL, store in database, trigger callback, etc.) Based on the available documentation, here are webhook receiver examples for the most common platforms: ## Node.js Example [(1) ]()
Copy code
javascript
// install the sdk: <https://docs.retellai.com/get-started/sdk>
import { Retell } from "retell-sdk";
import express from "express";
const app = express() ;
// Use raw body for signature verification, not JSON.stringify(req.body) .
app.use(express.raw({ type: "application/json" }) ) ;
app.post("/webhook", (req, res) => {
 const rawBody = req.body.toString("utf-8") ;
 if (
 !Retell.verify(
 rawBody,
 process.env.RETELL_API_KEY,
 req.headers["x-retell-signature"],
 )
 ) {
 console.error("Invalid signature") ;
 return;
 }
 const {event, call} = JSON.parse(rawBody) ;
 switch (event) {
 case "call_started":
 console.log("Call started event received", call.call_id) ;
 break;
 case "call_ended":
 console.log("Call ended event received", call.call_id) ;
 break;
 case "call_analyzed":
 console.log("Call analyzed event received", call.call_id) ;
 break;
 case "transcript_updated":
 console.log("Transcript updated event received", call.call_id) ;
 break;
 case "transfer_started":
 case "transfer_bridged":
 case "transfer_cancelled":
 case "transfer_ended":
 console.log("Transfer event received", event, call.call_id) ;
 break;
 default:
 console.log("Received an unknown event:", event) ;
 }

 // Acknowledge the receipt of the event
 res.status(204) .send() ;
}) ;
## Python Example
Copy code
python
from retell import Retell
from flask import Flask, request

app = Flask(__name__)

@app.route("/webhook", methods=["POST"])
def handle_webhook() :
    raw_body = request.data.decode("utf-8")
    
    if not Retell.verify(
        raw_body,
        os.environ["RETELL_API_KEY"],
        request.headers.get("X-Retell-Signature")
    ) :
        print("Invalid signature")
        return "", 401
    
    data = request.get_json()
    event = data.get("event")
    call = data.get("call")
    
    if event == "call_analyzed":
        print(f"Call analyzed: {call.get('call_id') }")
        # Access Post-Call Analysis data
        call_analysis = call.get("call_analysis", {})
        custom_data = call_analysis.get("custom_analysis_data", {})
        
        # Example: Check for callback request
        if custom_data.get("callback_requested") :
            callback_time = custom_data.get("callback_time")
            print(f"Callback requested for: {callback_time}")
    
    return "", 204
## Key Points About the Webhook The webhook will POST the payload to your endpoint . The webhook has a timeout of 10 seconds . If within 10 seconds no success status (2xx) is received, the webhook will be retried, up to 3 times . Tell me which platform you're using and what you want to do with the data, and I'll customize the code specifically for your GHL integration and callback workflow.
​ To learn more, see the sources I considered: [[1] Webhook Overview](https://docs.retellai.com/features/webhook-overview) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
1. idk standard i think 2. send to ghl for custom fields and trigger callback
@AI Evy i1. dk standard i think 2. send to ghl for custom fields and trigger callback
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Since you want to send Post-Call Analysis data to GHL custom fields and trigger callbacks, here's the complete webhook setup: ## Step 1: Set Up Webhook Endpoint in Retell AI Dashboard [(1) ]() Configure your webhook in the Retell AI dashboard to point to your GHL inbound webhook URL . Subscribe to the 
call_analyzed
event type . ## Step 2: Webhook Receiver Code (Node.js) [(2) ]()
Copy code
javascript
// install the sdk: <https://docs.retellai.com/get-started/sdk>
import { Retell } from "retell-sdk";
import express, { Request, Response } from "express";

const app = express() ;
app.use(express.json() ) ;

app.post("/webhook", (req: Request, res: Response) => {
  const {event, call} = req.body;
  
  switch (event) {
    case "call_started":
      console.log("Call started event received", call.call_id) ;
      break;
    case "call_ended":
      console.log("Call ended event received", call.call_id) ;
      break;
    case "call_analyzed":
      console.log("Call analyzed event received", call.call_id) ;
      break;
    default:
      console.log("Received an unknown event:", event) ;
  }
  
  // Acknowledge the receipt of the event
  res.status(204) .send() ;
}) ;
## Step 3: Extract Post-Call Analysis Data When the 
call_analyzed
event arrives, the payload structure will be [(1) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    
  }
}
The 
call_analysis
object contains [(1) ]() [(3) ]() [(4) ]() : - `call_summary`: Text summary of the call - `user_sentiment`: Sentiment analysis - `call_successful`: Boolean for success status - `custom_analysis_data`: Your custom extraction fields ## Step 4: Send to GHL Custom Fields Inside the 
call_analyzed
case, extract the custom analysis data and send it to your GHL API endpoint. The 
custom_analysis_data
field will contain fields like 
callback_requested
and 
callback_time
that you configured in your Post-Call Analysis settings . ## Step 5: Trigger Callback Based on the 
callback_requested
boolean and 
callback_time
fields in 
custom_analysis_data
, trigger your callback workflow in GHL . ## Important Notes Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place [(1) ]() . Always check whether the field exists before using it . The 
call_analyzed
webhook is the third webhook sent per call and is the only one containing Post-Call Analysis data [(5) ]() [(6) ]() .
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy i want you to also add all of the values i got from my past webhook this is important since its things my clients wants: { "type": "object", "properties": { "bedrooms": { "type": "string", "description": "The number of bedrooms in the property." }, "property_condition": { "type": "string", "description": "The overall condition of the property." }, "roof_condition": { "type": "string", "description": "The current condition of the roof." }, "occupancy": { "type": "string", "description": "The occupancy status of the property." }, "motivation_to_sell": { "type": "string", "description": "The seller's motivation or reason for selling." }, "ideal_close_date": { "type": "string", "description": "The seller's ideal closing date for the deal." }, "bathrooms": { "type": "string", "description": "The number of bathrooms in the property." }, "asking_price": { "type": "string", "description": "The seller's asking price for the property." }, "callback_requested": { "type": "boolean", "description": "Whether the user requested a callback." }, "callback_time": { "type": "string", "description": "The time the user wants to be called back. Must be in ISO format if available." } }, "required": [ "bathrooms", "bedrooms", "roof_condition", "occupancy", "motivation_to_sell", "asking_price", "property_condition", "ideal_close_date", "callback_requested" ] }
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on the thread history, you're mixing two different data extraction methods. Let me clarify how to combine both: ## Two Separate Systems Working Together *System 1: Custom Function (Real-time During Call) * [(1) ]() Your schema defines a custom function that extracts data during the conversation and sends it to your GHL webhook immediately. *System 2: Post-Call Analysis (After Call Ends) * [(2) ]() This extracts data after the call completes and sends it via the 
call_analyzed
webhook. ## Complete Webhook Receiver Code Here's the Node.js webhook receiver that handles both the custom function responses and the 
call_analyzed
event with all your property fields:
Copy code
javascript
import express from "express";
import { Retell } from "retell-sdk";

const app = express() ;
app.use(express.raw({ type: "application/json" }) ) ;

app.post("/webhook", (req, res) => {
  const rawBody = req.body.toString("utf-8") ;
  
  // Verify signature
  if (
    !Retell.verify(
      rawBody,
      process.env.RETELL_API_KEY,
      req.headers["x-retell-signature"],
    )
  ) {
    console.error("Invalid signature") ;
    return res.status(401) .send("Unauthorized") ;
  }

  const { event, call } = JSON.parse(rawBody) ;
  
  switch (event) {
    case "call_started":
      console.log("Call started event received", call.call_id) ;
      break;
      
    case "call_ended":
      console.log("Call ended event received", call.call_id) ;
      break;
      
    case "call_analyzed":
      console.log("Call analyzed event received", call.call_id) ;
      
      // Extract Post-Call Analysis data
      const callAnalysis = call.call_analysis || {};
      const customData = callAnalysis.custom_analysis_data || {};
      
      // Prepare data for GHL
      const ghlPayload = {
        call_id: call.call_id,
        call_summary: callAnalysis.call_summary,
        user_sentiment: callAnalysis.user_sentiment,
        call_successful: callAnalysis.call_successful,
        
        // Property details from Post-Call Analysis
        bedrooms: customData.bedrooms,
        bathrooms: customData.bathrooms,
        property_condition: customData.property_condition,
        roof_condition: customData.roof_condition,
        occupancy: customData.occupancy,
        motivation_to_sell: customData.motivation_to_sell,
        ideal_close_date: customData.ideal_close_date,
        asking_price: customData.asking_price,
        
        // Callback information
        callback_requested: customData.callback_requested,
        callback_time: customData.callback_time
Copy code
};
      
      // Send to GHL
      sendToGHL(ghlPayload) ;
      
      // Trigger callback workflow if requested
      if (customData.callback_requested) {
        triggerCallback(call.call_id, customData.callback_time) ;
      }
      break;
      
    default:
      console.log("Received an unknown event:", event) ;
  }
  
  res.status(204) .send() ;
}) ;

async function sendToGHL(payload) {
  // Your GHL API endpoint
  const ghlWebhookUrl = "YOUR_GHL_INBOUND_WEBHOOK_URL";
  
  try {
    const response = await fetch(ghlWebhookUrl, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify(payload)
    }) ;
    
    if (response.ok) {
      console.log("Data sent to GHL successfully") ;
    } else {
      console.error("Failed to send to GHL:", response.status) ;
    }
  } catch (error) {
    console.error("Error sending to GHL:", error) ;
  }
}

function triggerCallback(callId, callbackTime) {
  console.log(`Scheduling callback for call ${callId} at ${callbackTime}`) ;
  // Implement your callback scheduling logic here
  // This could trigger a GHL workflow or use Retell's Batch Dialer
}

app.listen(3000, () => {
  console.log("Webhook server running on port 3000") ;
}) ;
[(1) ]() ## Configuration Steps Step 1: Configure Post-Call Analysis in Retell AI Dashboard [(2) ]() Create custom analysis categories matching your schema fields: - 
bedrooms
(Text type) - 
bathrooms
(Text type) - 
property_condition
(Text or Selector type) - 
roof_condition
(Text or Selector type) - 
occupancy
(Text or Selector type) - 
motivation_to_sell
(Text type) - 
ideal_close_date
(Text type) - 
asking_price
(Text type) - 
callback_requested
(Boolean type) - 
callback_time
(Text type) Step 2: Register Webhook in Retell AI Point your webhook to your server endpoint and subscribe to the 
call_analyzed
event type. Step 3: Keep Your Custom Function [(1) ]() Your existing custom function schema can remain as-is for real-time data extraction during calls. ## Important Notes Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place [(2) ]() . Always check whether fields exist before using them. The 
call_analyzed
webhook is the third webhook sent per call and contains the Post-Call Analysis data in the 
custom_analysis_data
object [(2) ]() [(3) ]() .
​ To learn more, see the sources I considered: [[1] Integrate any system with custom function](https://docs.retellai.com/build/single-multi-prompt/custom-function) [[2] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[3] List Calls](https://docs.retellai.com/api-references/list-calls) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy it should be in json
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer The 
call_analyzed
webhook payload from Retell AI is already in JSON format [(1) ]() [(2) ]() . When Retell AI sends the webhook to your endpoint, it POSTs a JSON payload [(2) ]() . Here's the exact JSON structure you'll receive from the 
call_analyzed
webhook [(1) ]() [(2) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
    "agent_id": "oBeDLoLOeuAbiuaMFXRtDOLriTJ5tSxD",
    "call_analysis": {
      "call_summary": "The agent called the user to ask question about his purchase inquiry. The agent asked several questions regarding his preference and asked if user would like to book an appointment. The user happily agreed and scheduled an appointment next Monday 10am.",
      "in_voicemail": false,
      "user_sentiment": "Positive",
      "call_successful": true,
      "custom_analysis_data": {}
    }
  }
}
[(2) ]() The 
custom_analysis_data
object will contain your custom Post-Call Analysis fields [(1) ]() [(3) ]() . Based on your property fields, it would look like:
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
    "call_analysis": {
      "call_summary": "Summary text here",
      "user_sentiment": "Positive",
      "call_successful": true,
      "custom_analysis_data": {
        "bedrooms": "3",
        "bathrooms": "2",
        "property_condition": "Good",
        "roof_condition": "Needs repair",
        "occupancy": "Owner occupied",
        "motivation_to_sell": "Relocating for work",
        "ideal_close_date": "2026-06-15",
        "asking_price": "350000",
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
Your GHL inbound webhook will receive this JSON payload automatically after each call completes and is analyzed [(1) ]() [(2) ]() . The webhook has a timeout of 10 seconds [(2) ]() .
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Webhook Overview](https://docs.retellai.com/features/webhook-overview) [[3] List Calls](https://docs.retellai.com/api-references/list-calls) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
why 2 woudnt it be distracting for ghl also if its possible can u make it only 1 @AI Evy
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer You're receiving three separate webhook events per call from Retell AI [(1) ]() : 1. 
call_started
- When call begins 2. 
call_ended
- When call finishes 3. 
call_analyzed
- When Post-Call Analysis completes (contains your custom extraction data) You can filter to receive ONLY the 
call_analyzed
webhook to avoid multiple payloads hitting GHL . Here's how to set up a single webhook that only processes Post-Call Analysis data: ## Single Webhook Solution Configure your webhook to only subscribe to the 
call_analyzed
event type . This ensures GHL receives just one payload per call containing all your property fields. The 
call_analyzed
event includes everything you need in 
custom_analysis_data
[(1) ]() [(2) ]() [(3) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
    "call_analysis": {
      "call_summary": "Summary text here",
      "user_sentiment": "Positive",
      "call_successful": true,
      "custom_analysis_data": {
        "bedrooms": "3",
        "bathrooms": "2",
        "property_condition": "Good",
        "roof_condition": "Needs repair",
        "occupancy": "Owner occupied",
        "motivation_to_sell": "Relocating for work",
        "ideal_close_date": "2026-06-15",
        "asking_price": "350000",
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
## Important Note Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place [(1) ]() . Always check whether the field exists before using it in GHL. **Result**: GHL receives exactly one webhook per call containing all your property extraction data after the call completes and is analyzed .
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Create Phone Call](https://docs.retellai.com/api-references/create-phone-call) [[3] List Calls](https://docs.retellai.com/api-references/list-calls) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
add a phone number like from who was the phone number we called bcs were gonna do outbound just add it in the code
@AI Evy add a phone number like from who was the phone number we called bcs were gonna do outbound just add it in the code
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer The 
call_analyzed
webhook payload already includes phone number information for outbound calls. Here's the updated JSON structure showing the phone number fields [(1) ]() [(2) ]() [(3) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
    "call_type": "phone_call",
    "from_number": "+14157774444",
    "to_number": "+12137774445",
    "direction": "outbound",
    "call_analysis": {
      "call_summary": "Summary text here",
      "user_sentiment": "Positive",
      "call_successful": true,
      "custom_analysis_data": {
        "bedrooms": "3",
        "bathrooms": "2",
        "property_condition": "Good",
        "roof_condition": "Needs repair",
        "occupancy": "Owner occupied",
        "motivation_to_sell": "Relocating for work",
        "ideal_close_date": "2026-06-15",
        "asking_price": "350000",
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
The key fields for outbound calls are : - **`from_number`**: Your Retell-managed or imported number (the number you're calling from) - **`to_number`**: The destination number (the customer you called) - **`direction`**: Will be 
"outbound"
for outbound calls When you send data to GHL, include these phone number fields in your payload:
Copy code
javascript
const ghlPayload = {
  call_id: call.call_id,
  from_number: call.from_number,
  to_number: call.to_number,
  direction: call.direction,
  call_summary: callAnalysis.call_summary,
  user_sentiment: callAnalysis.user_sentiment,
  call_successful: callAnalysis.call_successful,
  
  // Property details
  bedrooms: customData.bedrooms,
  bathrooms: customData.bathrooms,
  property_condition: customData.property_condition,
  roof_condition: customData.roof_condition,
  occupancy: customData.occupancy,
  motivation_to_sell: customData.motivation_to_sell,
  ideal_close_date: customData.ideal_close_date,
  asking_price: customData.asking_price,
  
  // Callback information
  callback_requested: customData.callback_requested,
  callback_time: customData.callback_time
};
This gives you complete tracking of which number you called from and which customer number you reached .
​ To learn more, see the sources I considered: [[1] Register Phone Call](https://docs.retellai.com/api-references/register-phone-call) [[2] List Calls](https://docs.retellai.com/api-references/list-calls) [[3] Create Phone Call](https://docs.retellai.com/api-references/create-phone-call) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy tell me again whats the process so i can have a clear call back
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
    "from_number": "+14157774444",
    "to_number": "+12137774445",
    "direction": "outbound",
    "call_analysis": {
      "call_summary": "Summary text here",
      "user_sentiment": "Positive",
      "call_successful": true,
      "custom_analysis_data": {
        "bedrooms": "3",
        "bathrooms": "2",
        "property_condition": "Good",
        "roof_condition": "Needs repair",
        "occupancy": "Owner occupied",
        "motivation_to_sell": "Relocating for work",
        "ideal_close_date": "2026-06-15",
        "asking_price": "350000",
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
Step 4: GHL Processes the Data Your GHL inbound webhook receives the 
call_analyzed
event [(1) ]() . Map the fields from 
custom_analysis_data
to your GHL custom fields [(1) ]() [(2) ]() . Step 5: Trigger Callback Workflow in GHL When 
callback_requested
is 
true
, use the 
callback_time
value to trigger your GHL workflow that schedules the callback . ## Important Notes Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place [(1) ]() . Always check whether the field exists before using it . The 
call_analyzed
webhook is the third webhook sent per call and is the only one containing Post-Call Analysis data .
### Answer Here's the complete process to set up automated callbacks using Retell AI Post-Call Analysis and GHL: ## Complete Callback Setup Process Step 1: Configure Post-Call Analysis in Retell AI Dashboard [(1) ]() Go to your agent detail page and click the "Post-Call Analysis" tab . Create these custom analysis categories: - 
callback_requested
(Boolean type) - Whether user wants a callback - 
callback_time
(Text type) - When they want to be called back - 
bedrooms
(Text type) - 
bathrooms
(Text type) - 
property_condition
(Text type) - 
roof_condition
(Text type) - 
occupancy
(Text type) - 
motivation_to_sell
(Text type) - 
ideal_close_date
(Text type) - 
asking_price
(Text type) Step 2: Set Up Webhook in Retell AI Dashboard Configure a webhook pointing to your GHL inbound webhook URL and subscribe to ONLY the 
call_analyzed
event type . Step 3: Receive the Webhook Payload After each call ends and is analyzed, Retell AI will POST this JSON payload to your GHL webhook [(1) ]() [(2) ]() :
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] List Calls](https://docs.retellai.com/api-references/list-calls) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy Here's the thing: we already have the post-call extraction so basically how the full system works is: 1. We send SMS and if they don't answer we send out calls using Sympana Connector, connecting to Util.AI. 2. After the call we get the information from Util.AI to Go High Level using Webhooks. 3. Then after Webhooks we extract all of the information using Fine Context and after that we add tags to people that requested a callback. Right? The main problem is I've got a second Webhook in Go High Level that basically sends callbacks. I know you said that we could use something that's called Retell AI Schedule Call. How can I create that from the full infrastructure, the full system that I currently have? Tell me step by step anything that I need.
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Unfortunately, I don't have information in the available sources about "Retell AI Schedule Call" or how to schedule callbacks directly through Retell AI's API based on post-call analysis data [(1) ]() . However, based on your current infrastructure, here's how you can integrate Retell AI for automated callbacks: ## Your Current System + Retell AI Integration Step 1: Replace Util.AI with Retell AI Instead of using Sympana Connector to connect to Util.AI, connect directly to Retell AI for making outbound calls. You'll use Retell AI's Create Phone Call API to initiate calls [(2) ]() . Step 2: Configure Post-Call Analysis in Retell AI Set up your custom analysis fields in Retell AI dashboard (as we discussed earlier) : - 
callback_requested
(Boolean) - 
callback_time
(Text) - All your property fields (bedrooms, bathrooms, etc.) Step 3: Receive 
call_analyzed
Webhook in GHL When a call completes, Retell AI sends the 
call_analyzed
webhook to your GHL inbound webhook URL [(1) ]() . This webhook contains all your extracted data in 
custom_analysis_data
. Step 4: GHL Workflow Triggers Callback In GHL, when the webhook arrives with 
callback_requested: true
, your existing second webhook workflow triggers to schedule the callback using the 
callback_time
value. Step 5: Callback Execution When it's time for the callback, your GHL workflow can trigger a new outbound call through Retell AI by calling the Create Phone Call API again [(2) ]() . ## What You Need I don't have specific documentation about automated callback scheduling within Retell AI itself. You may want to check the [official documentation](https://
docs.retellai.com) or contact support for information about native callback scheduling features. For now, your GHL second webhook workflow can continue handling callback scheduling, just receiving the trigger data from Retell AI's 
call_analyzed
webhook instead of Util.AI [(1) ]() .
​ To learn more, see the sources I considered: [[1] Webhook Overview](https://docs.retellai.com/features/webhook-overview) [[2] Register Phone Call](https://docs.retellai.com/api-references/register-phone-call) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy I don't get how we could create a callback for them using only one agent. How would that work? Right cause we send SMS if they don't answer; we call them and then we call them back if they say yes. We call them back in a specific way. How can I specifically do that? I'm not saying, just to recap with my previous message, I'm not saying "Just tell AI"; I'm saying "Retell AI".
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer To handle callbacks using one Retell AI agent, you'll use the same agent for both the initial call and the callback. Here's how the complete flow works: ## Complete Callback Flow with Retell AI *Initial Outbound Call (First Touch) * When making your first outbound call through Retell AI, use the Create Phone Call API [(1) ]() :
Copy code
javascript
import Retell from 'retell-sdk';
const client = new Retell({
 apiKey: process.env['RETELL_API_KEY'],
}) ;
const phoneCallResponse = await client.call.createPhoneCall({
 from_number: '+14157774444',
 to_number: '+12137774445',
}) ;
*Callback Scheduling (When User Says "Call Me Back") * After the initial call completes, Retell AI sends the 
call_analyzed
webhook to GHL containing 
callback_requested: true
and 
callback_time
. Your GHL workflow stores this information and schedules the callback. *Executing the Callback (Second Touch) * When it's time for the callback, your GHL workflow triggers another outbound call using the same agent through the Create Phone Call API again :
Copy code
javascript
const callbackResponse = await client.call.createPhoneCall({
 from_number: '+14157774444',
 to_number: '+12137774445',
}) ;
The key insight: You're using the same agent for both calls, but making two separate API calls - one for the initial outbound call, and another for the callback . ## How to Customize the Agent's Behavior for Callbacks If you need the agent to behave differently during callbacks (e.g., "Hi, this is the callback you requested") , you can pass dynamic variables when creating the callback call :
Copy code
javascript
const callbackResponse = await client.call.createPhoneCall({
 from_number: '+14157774444',
 to_number: '+12137774445',
 retell_llm_dynamic_variables: {
  is_callback: "true",
  original_request_time: "yesterday at 2pm"
 }
}) ;
These dynamic variables inject into your agent's prompt, allowing it to acknowledge it's a callback . ## Summary One agent handles both scenarios by making two separate API calls through the Create Phone Call endpoint - the initial call and the scheduled callback . GHL orchestrates the timing between these calls based on the 
callback_time
extracted from the first call's analysis .
​ To learn more, see the sources I considered: [[1] Create Phone Call](https://docs.retellai.com/api-references/create-phone-call) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy But what specific workflow should I use for the callbacks? Like how I could just say, "Inside Go High Level" or "Inside RetellAI," Like if they say, "Call me at 2 p.m." How can I create a callback specifically for 2pm? Is it using a GoHigh workflow or is it using inside Retail AI?
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on the available sources, the callback scheduling happens in Go High Level, not inside Retell AI [(1) ]() [(2) ]() . Here's how the workflow works: ## Callback Scheduling Process Step 1: Retell AI Extracts Callback Information During the call, Retell AI's Post-Call Analysis extracts 
callback_requested
and 
callback_time
from the conversation [(1) ]() . Step 2: Retell AI Sends 
call_analyzed
Webhook to GHL After the call ends and is analyzed, Retell AI sends this JSON payload to your GHL webhook [(1) ]() [(2) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_analysis": {
      "custom_analysis_data": {
        "callback_requested": true,
        "callback_time": "2pm"
      }
    }
  }
}
[(1) ]() Step 3: GHL Workflow Schedules the Callback Your Go High Level workflow receives this webhook and: - Checks if 
callback_requested
is 
true
- Parses the 
callback_time
value ("2pm", "tomorrow at 2pm", etc.) - Schedules a delayed action/wait step in GHL until that time Step 4: GHL Triggers New Retell AI Call at Scheduled Time When the scheduled time arrives, your GHL workflow makes a new API call to Retell AI's Create Phone Call endpoint [(2) ]() :
Copy code
javascript
const callbackResponse = await client.call.createPhoneCall({
  from_number: '+14157774444',
  to_number: '+12137774445',
  retell_llm_dynamic_variables: {
    is_callback: "true"
  }
}) ;
## Summary **Retell AI's role**: Extract callback request and time, send to GHL via webhook [(1) ]() **GHL's role**: Schedule the callback using GHL's workflow automation (wait/delay actions) and trigger a new Retell AI call at the scheduled time Retell AI does not have built-in callback scheduling functionality in the available sources. The scheduling logic must be handled by your GHL workflow [(1) ]() [(2) ]() .
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Create Phone Call](https://docs.retellai.com/api-references/create-phone-call) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy Now with our full conversation tell me step-by-step what my infrastructure is, my system is, and everything
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on our conversation, here's your complete infrastructure step-by-step: ## Your Complete System Architecture *Step 1: Initial Lead Contact (SMS First Touch) * Send SMS to leads through Go High Level. If they don't respond, proceed to Step 2. *Step 2: Initial Outbound Call (First Voice Touch) * When SMS doesn't get a response, trigger an outbound call through Retell AI using the Create Phone Call API [(1) ]() :
Copy code
javascript
import Retell from 'retell-sdk';
const client = new Retell({
  apiKey: process.env['RETELL_API_KEY'],
}) ;
const phoneCallResponse = await client.call.createPhoneCall({
  from_number: '+14157774444',
  to_number: '+12137774445',
}) ;
Step 3: Post-Call Data Extraction After the call ends, Retell AI automatically analyzes the conversation and sends a 
call_analyzed
webhook to your GHL inbound webhook URL [(2) ]() . The webhook payload contains [(2) ]() [(1) ]() [(3) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_id": "Jabr9TXYYJHfvl6Syypi88rdAHYHmcq6",
    "from_number": "+14157774444",
    "to_number": "+12137774445",
    "direction": "outbound",
    "call_analysis": {
      "call_summary": "Summary text here",
      "user_sentiment": "Positive",
      "call_successful": true,
      "custom_analysis_data": {
        "bedrooms": "3",
        "bathrooms": "2",
        "property_condition": "Good",
        "roof_condition": "Needs repair",
        "occupancy": "Owner occupied",
        "motivation_to_sell": "Relocating for work",
        "ideal_close_date": "2026-06-15",
        "asking_price": "350000",
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
[(2) ]() Step 4: GHL Processes Webhook Data Your GHL inbound webhook receives the 
call_analyzed
event . Map all fields from 
custom_analysis_data
to your GHL custom fields [(2) ]() [(3) ]() . Step 5: Tag Leads Requesting Callbacks In GHL, when 
callback_requested
is 
true
, add a tag to the contact indicating they requested a callback. Step 6: GHL Workflow Schedules Callback Your second GHL webhook workflow: - Checks if the contact has the callback tag - Parses the 
callback_time
value ("2pm", "tomorrow at 2pm", etc.) - Uses GHL's wait/delay action to schedule the callback for that specific time Step 7: Execute Scheduled Callback When the scheduled time arrives, your GHL workflow triggers a new outbound call to Retell AI using the Create Phone Call API again [(1) ]() :
Copy code
javascript
const callbackResponse = await client.call.createPhoneCall({
  from_number: '+14157774444',
  to_number: '+12137774445',
  retell_llm_dynamic_variables: {
    is_callback: "true",
    original_request_time: "yesterday at 2pm"
  }
}) ;
Step 8: Callback Call Completes The callback call follows the same flow as Step 3-4, sending another 
call_analyzed
webhook to GHL with updated information. ## Key Configuration Requirements In Retell AI Dashboard: - Configure Post-Call Analysis with custom fields: 
callback_requested
(Boolean) , 
callback_time
(Text) , 
bedrooms
, 
bathrooms
, 
property_condition
, 
roof_condition
, 
occupancy
, 
motivation_to_sell
, 
ideal_close_date
, 
asking_price
[(2) ]() - Set up webhook pointing to your GHL inbound webhook URL - Subscribe to ONLY the 
call_analyzed
event type to avoid multiple webhooks In Go High Level: - Inbound webhook to receive 
call_analyzed
events from Retell AI - Workflow to map extracted data to custom fields - Workflow to tag contacts when 
callback_requested
is true - Second workflow with wait/delay action to schedule callbacks based on 
callback_time
- Workflow to trigger new Retell AI calls at scheduled times ## Important Notes Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place . Always check whether fields exist before using them in GHL workflows. You're using the same Retell AI agent for both initial calls and callbacks, but making two separate API calls through the Create Phone Call endpoint [(1) ]() .
​ To learn more, see the sources I considered: [[1] Create Phone Call](https://docs.retellai.com/api-references/create-phone-call) [[2] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[3] List Calls](https://docs.retellai.com/api-references/list-calls) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy can retellai situation test can receive ghl inbound webhooks like heres step by step retellai situation go to ghl inbound webhook and runs the full automation inside ghl
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer No, Retell AI Simulation Testing cannot receive GHL inbound webhooks or trigger external automations. Retell AI's Simulation Testing is designed to test your AI agents internally by simulating conversations—it does not interact with external systems like Go High Level [(1) ]() . ## What Simulation Testing Actually Does Simulation Testing allows you to write a user prompt to quickly simulate a full conversation with your agent . You can also run Batch Simulation Testing to test multiple scenarios at once . This feature is for testing your agent's behavior before deployment, not for integrating with external webhooks or automation platforms. ## The Correct Flow for GHL Integration Based on our entire conversation, here's what actually happens: 1. Retell AI makes calls (initial or callback) 2. Retell AI sends webhooks TO GHL (not the other way around) 3. GHL receives the 
call_analyzed
webhook from Retell AI 4. GHL workflows process the data and trigger automations Retell AI sends webhooks to GHL—it doesn't receive webhooks from GHL to trigger simulations. Simulation Testing is a separate testing tool that runs independently within the Retell AI platform . If you want to test your full system including GHL automation, you would need to make actual test calls through Retell AI, which would then trigger your real GHL webhooks and workflows.
​ To learn more, see the sources I considered: [[1] Simulation Testing Now Live for All Agents](https://www.retellai.com/changelog/simulation-testing-now-live-for-all-agents-c27zh) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
problem rn is my phone coudnt receive calls for testing @AI Evy
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer If your phone can't receive calls for testing, you have an alternative: use Web Calls instead of phone calls for testing [(1) ]() . ## Testing with Web Calls You can create a Web Call to test your agent without needing a phone number. Use the Create Web Call API :
Copy code
javascript
import Retell from 'retell-sdk';
const client = new Retell({
  apiKey: process.env['RETELL_API_KEY'],
}) ;
const webCallResponse = await client.call.createWebCall({
  agent_id: 'oBeDLoLOeuAbiuaMFXRtDOLriTJ5tSxD',
}) ;
This returns an 
access_token
that you can use to join the call from your browser instead of your phone . ## Alternative: Test with a Different Number If you need to test actual phone calls, you could: 1. Use a different phone number for testing (friend's phone, Google Voice number, etc.) 2. Check your phone number configuration - ensure the inbound agent is properly bound to your number [(2) ]() 3. Verify your number settings - check that your number accepts inbound calls and doesn't have country restrictions blocking your test calls [(3) ]() For inbound calls to work, you must bind an agent to your phone number [(2) ]() . You can configure this in your phone number settings [(2) ]() [(3) ]() . If you're using imported numbers via SIP trunking, verify your origination settings with your telephony provider [(4) ]() .
​ To learn more, see the sources I considered: [[1] Create Web Call](https://docs.retellai.com/api-references/create-web-call) [[2] Receive calls](https://docs.retellai.com/deploy/inbound-call) [[3] Create Phone Number](https://docs.retellai.com/api-references/create-phone-number) [[4] Custom Telephony Overview](https://docs.retellai.com/deploy/custom-telephony) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
Thanks for the follow-up, @Zai. I'll get back to you soon.
z
@AI Evy my sympana connector says this do i need to add prompt in my prompt to say this is for this or in post call and the problem is the postcode extraction that I use in Sympana doesn't give the postcode extraction in Retail AI. For example it's connected using a webhook but it just doesn't give the information from the postcode extraction https://cdn.discordapp.com/attachments/1497250197603090597/1503010371387261048/message.txt?ex=6a01cafd&is=6a00797d&hm=027098850c3c1700a35b52b479b39aa652830f5511df4c6a69dc197239ef10bc&
a
### Answer The issue you're experiencing is that Sympana Connector's post-call extraction fields won't automatically appear in Retell AI's webhook. Retell AI and Sympana are separate systems with different extraction mechanisms [(1) ]() . ## The Solution: Configure Post-Call Analysis in Retell AI You need to set up Post-Call Analysis directly in Retell AI to extract the data you need, including the postcode [(1) ]() [(2) ]() . Step 1: Add Custom Post-Call Analysis Fields in Retell AI Dashboard Go to your Retell AI agent detail page → Post-Call Analysis tab . Create a custom analysis field: - **Field name**: 
postcode
(or 
postal_code
) - **Type**: Text - **Description/Prompt**: "Extract the postal code or postcode mentioned by the user during the conversation" Step 2: The Data Will Appear in the 
call_analyzed
Webhook After the call ends and is analyzed, Retell AI will send this payload to your GHL webhook [(1) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_analysis": {
      "custom_analysis_data": {
        "postcode": "12345",
        "bedrooms": "3",
        "bathrooms": "2"
      }
    }
  }
}
## Important Notes Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place . Always check whether the field exists before using it in your workflows . The 
call_analyzed
webhook is sent after the call ends and contains all your extracted Post-Call Analysis data . This is separate from any Sympana extraction—you're now using Retell AI's native extraction instead. If you're still not receiving the post-call analysis data in your webhook, verify that you've subscribed to the 
call_analyzed
event type in your Retell AI webhook settings [(1) ]() [(3) ]() .
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Unlock Insights with Post-Call Analysis | Retell AI](https://www.retellai.com/features/post-call-analysis) [[3] Webhook Does Not Deliver Post-Call Analysis Data](https://discord.com/channels/1186424376300679209/1390601008882913300) ​
z
@AI Evy Here's how the Sympana AI on integrating the webhook forwarding, since it already has a webhook but I use a webhook inside Go High Level for receiving, Simpano also has its own webhook. What I did is put the webhook inside Go High Level for receiving in the webhook forwarding so when a call comes it would go into that specific webhook in Go High Level . So that's why I'm thinking the one that I pasted ago, like Oh My Simpana, also does go high-level custom fields. Should I create prompts inside my Simpana prompt for Simpana to recreate the go high-level custom fields? Or revise the custom fields Via the answers of the customer or lead https://cdn.discordapp.com/attachments/1497250197603090597/1503011415445995600/image.png?ex=6a01cbf6&is=6a007a76&hm=6a9c062bf170f1ed75f775004c47db8188545d989293675d21671488e7cfa8ab&
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on the available sources, I don't have specific information about Sympana's webhook forwarding configuration or how to configure prompts within Sympana itself. However, if you're planning to transition to Retell AI (as we've been discussing throughout this conversation) , here's what you should do: ## Recommended Approach: Use Retell AI's Native Post-Call Analysis Instead of relying on Sympana's extraction and webhook forwarding, configure Post-Call Analysis directly in Retell AI [(1) ]() . This eliminates the need for intermediate webhook forwarding and gives you direct control over what data gets extracted. Configure Custom Fields in Retell AI Dashboard: Go to your agent detail page → Post-Call Analysis tab and create custom analysis fields that match your GHL custom fields : - 
postcode
(Text) - 
bedrooms
(Text) - 
bathrooms
(Text) - 
property_condition
(Text) - 
callback_requested
(Boolean) - 
callback_time
(Text) Retell AI Sends Data Directly to GHL: After each call, Retell AI will send the 
call_analyzed
webhook directly to your GHL inbound webhook URL :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_analysis": {
      "custom_analysis_data": {
        "postcode": "12345",
        "bedrooms": "3",
        "bathrooms": "2",
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
No Webhook Forwarding Needed: With Retell AI, you point the webhook directly to GHL—no intermediate forwarding required . ## Important Note Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place . Always check whether the field exists before using it in your GHL workflows. If you continue using Sympana, you'll need to consult Sympana's documentation for how to configure their prompts and extraction fields—that's outside the scope of Retell AI documentation.
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
Problem is how can I direct it to do that? Should I still use a webhook? I already used the custom function and probably the custom function. I don't fucking know but it disappears when I use it, like when I update it. Right away when I check it again, it disappears but then when I call someone, then the thing won't even do something. Like what should I use for the custom fields or how should I create the direct post-costum analysis?
@AI Evy Problem is how can I direct it to do that? Should I still use a webhook? I already used the custom function and probably the custom function. I don't fucking know but it disappears when I use it, like when I update it. Right away when I check it again, it disappears but then when I call someone, then the thing won't even do something. Like what should I use for the custom fields or how should I create the direct post-costum analysis?
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on the issues you're describing (custom fields disappearing, post-call analysis not working) , here's the step-by-step process to properly set up Post-Call Analysis in Retell AI: ## How to Access Post-Call Analysis Data Yes, you MUST use a webhook to receive post-call analysis data [(1) ]() . There are three methods to consume the analysis data : 1. Dashboard - Visual interface for quick access and review 2. Webhook - Real-time notifications with analysis results 3. API - Programmatic access to call analysis data For your GHL integration, you need the webhook method . ## Setting Up the Webhook Configure your webhook to receive the 
call_analyzed
event . The webhook payload will look like this :
Copy code
json
{
 "event_type": "call_analyzed",
 "call": {
 // Call object with call_analysis field populated
 }
}
## Troubleshooting Your Disappearing Custom Fields Issue Based on community reports, this is a known issue others have experienced [(2) ]() [(3) ]() [(4) ]() . Here are the common causes: You're checking the wrong webhook event - Post-call analysis data ONLY appears in the 
call_analyzed
webhook, NOT in 
call_started
or 
call_ended
[(5) ]() [(2) ]() . Each call triggers 3 different webhooks, and the custom analysis data is only in the third one [(2) ]() . You need to filter for 
call_analyzed
events - Set up a filter in your webhook receiver to only process 
call_analyzed
events . Other users reported this solved their issue . Custom analysis fields won't populate for failed calls - Post-call analysis fields are NOT populated for calls that were not connected or where no conversation took place [(1) ]() . Always check whether the field exists before using it . ## How to Verify It's Working After configuring post-call analysis in your Retell AI dashboard, make a test call and check your webhook logs. You should see 
custom_analysis_data
appear in the third webhook (the 
call_analyzed
event) [(2) ]() . If you're still not seeing the data after verifying you're checking the 
call_analyzed
webhook, contact Retell AI support directly,
as there may be a configuration issue with your specific account [(3) ]() [(4) ]() .
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Discord message from @keshav3 on 2025-01-30](https://discord.com/channels/1186424376300679209/1186462578310910112/1334444968156332126) [[3] postPost-call analysis: Data is gathered but not sent via webhook..why?](https://discord.com/channels/1186424376300679209/1399744779998461952) [[4] Webhook Does Not Deliver Post-Call Analysis Data](https://discord.com/channels/1186424376300679209/1390601008882913300) [[5] I'm trying to use make to send over data from post analysis call to excel](https://discord.com/channels/1186424376300679209/1314629061732991068) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy Problem with that one, just like it's a webhook, then there's the agent-level webhook URL. The problem with the agent webhook URL is that Simpano AI is already using it. If I need to call from Go High Level to Simpano or to Retail, I use Simpano for the calling so I'm thinking I should use Simpano also for my receiving. I'm thinking how should I do that with the post-call, like receiving the post-call extraction?
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on your specific setup with Sympana already using the agent-level webhook URL, you have two options for receiving post-call analysis data from Retell AI: ## Option 1: Use Account-Level Webhooks (Recommended) Instead of setting the 
webhook_url
at the agent level, configure an account-level webhook in your Retell AI dashboard [(1) ]() . This allows you to: - Keep Sympana using the agent-level webhook URL - Receive post-call analysis data through a separate account-level webhook pointing directly to GHL Set up the account-level webhook through the dashboard's webhooks tab . Any event associated with your agents will be pushed to this URL, unless an agent has its own 
webhook_url
set . ## Option 2: Remove Agent-Level Webhook and Use Account-Level Only If Sympana doesn't require the agent-level webhook, you can: 1. Set the agent's 
webhook_url
field to 
null
to remove it [(2) ]() [(3) ]() 2. Configure the account-level webhook to point to your GHL inbound webhook URL This way, all webhook events (including 
call_analyzed
) will go directly to GHL [(1) ]() . ## Configuring Webhook Events Regardless of which option you choose, ensure you're subscribed to the 
call_analyzed
event [(1) ]() [(2) ]() [(3) ]() [(4) ]() :
Copy code
json
{
  "webhook_events": [
    "call_started",
    "call_ended", 
    "call_analyzed"
  ]
}
[(2) ]() [(3) ]() [(4) ]() The 
call_analyzed
webhook will contain your post-call analysis data in the payload [(5) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_analysis": {
      "custom_analysis_data": {
        "postcode": "12345",
        "bedrooms": "3"
      }
    }
  }
}
## Important Notes - If an agent has 
webhook_url
set, the account-level webhook will NOT be triggered for that agent [(1) ]() [(3) ]() - The webhook has a timeout of 10 seconds and will retry up to 3 times if no success status (2xx) is received [(1) ]() - Post-call analysis fields are NOT populated for calls that were not connected or where no conversation took place [(5) ]()
​ To learn more, see the sources I considered: [[1] Webhook Overview](https://docs.retellai.com/features/webhook-overview) [[2] Create Voice Agent](https://docs.retellai.com/api-references/create-agent) [[3] Update Voice Agent](https://docs.retellai.com/api-references/update-agent) [[4] Get Agent Versions](https://docs.retellai.com/api-references/get-agent-versions) [[5] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy But what are your thoughts on me using sympana connectors still webhook because they have this custom function or this function inside of their system? I'm going to paste it down here. Should I just revise the prompt inside my retail AI or my agent so it could get the information and put it back down into go high level? pasted https://cdn.discordapp.com/attachments/1497250197603090597/1503013158783160390/message.txt?ex=6a01cd95&is=6a007c15&hm=1806d11c82be6a5c2ca9609a233631651538170f19c0dc4e8fecf152c2aca300&
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer I don't have specific documentation about Sympana Connector's custom functions, but I can provide guidance on the Retell AI side of your setup. ## My Recommendation: Use Retell AI's Native Post-Call Analysis Instead of relying on Sympana's custom functions and complex webhook forwarding, configure Post-Call Analysis directly in Retell AI [(1) ]() . This gives you direct control and eliminates intermediate systems. ## How to Set This Up in Retell AI Configure Post-Call Analysis Fields In your Retell AI agent dashboard, go to Post-Call Data Extraction (formerly Post-Call Analysis) and create custom fields for the data you need : - 
postcode
(Text) - 
bedrooms
(Text) - 
bathrooms
(Text) - 
callback_requested
(Boolean) - 
callback_time
(Text) Configure the Webhook to Send Directly to GHL Set your agent's webhook URL to point directly to your GHL inbound webhook [(1) ]() [(2) ]() :
Copy code
javascript
const agentResponse = await client.agent.update('16b980523634a6dc504898cda492e939', {
  webhook_url: "<https://your-ghl-webhook-url%22,>
  webhook_events: [
    "call_analyzed"
  ]
}) ;
[(2) ]() Receive the Data in GHL After each call ends and is analyzed, Retell AI will send this payload directly to your GHL webhook [(1) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_analysis": {
      "custom_analysis_data": {
        "postcode": "12345",
        "bedrooms": "3",
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm"
      }
    }
  }
}
## Important: Rerunning Analysis After Prompt Changes If you update your Post-Call Analysis prompts in Retell AI, you can rerun the analysis to regenerate results [(3) ]() . When you rerun analysis for a call, the system always uses the analysis prompts from the latest draft version of the agent—even if the call was originally handled by an older published version . ## Critical Notes Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place [(1) ]() . Always check whether the field exists before using it in your GHL workflows . The 
call_analyzed
webhook is the ONLY webhook that contains your post-call analysis data [(4) ]() [(5) ]() [(6) ]() . You will receive 3 webhooks per call (
call_started
, 
call_ended
, 
call_analyzed
) , and the custom analysis data only appears in the third one [(5) ]() . **Bottom line**: You don't need Sympana's custom functions for post-call data extraction if you configure Retell AI's native Post-Call Analysis properly. This simplifies your architecture significantly.
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Update Voice Agent](https://docs.retellai.com/api-references/update-agent) [[3] Rerun Post-Call/Chat Analysis](https://docs.retellai.com/features/rerun-call-analysis) [[4] Webhook not delivering Post-Call Analysis variables](https://discord.com/channels/1186424376300679209/1369886917893820457) [[5] Post Call Analysis Data not able to select in Make.](https://discord.com/channels/1186424376300679209/1425229235567460423) [[6] Discord message from @sujaishanmugam on 2025-04-14](https://discord.com/channels/1186424376300679209/1186462578310910112/1361251902611787866) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy Check this one and it specifically said here this : Retell auto-sync: When you save this connection, we will configure the Retell agent's post-call analysis to extract a field named contact_bathrooms. On call_analyzed, we will write the extracted value into this GHL custom field only if the field is empty. So that's why I'm asking: you should I create prompts inside my breach lii so when it goes back to my go high level, it can change the custom field https://cdn.discordapp.com/attachments/1497250197603090597/1503014246013993110/message.txt?ex=6a01ce98&is=6a007d18&hm=ce1ec374139ca68cd741f11976925ab1c8c27de87cdd0647198eca5ecec00a8e&
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on what you've described, it appears Sympana is automatically configuring Retell AI's Post-Call Analysis for you. However, you still need to properly configure the Post-Call Analysis fields in Retell AI for this to work [(1) ]() [(2) ]() . ## What You Need to Do in Retell AI Configure Post-Call Analysis Fields In your Retell AI agent dashboard, go to the Post-Call Data Extraction section and create a custom analysis field : - **Field name**: 
contact_bathrooms
(must match exactly what Sympana expects) - **Type**: Text or Number - **Description/Prompt**: "Extract the number of bathrooms mentioned by the user during the conversation" You can add additional fields for all the data you need extracted [(2) ]() : - 
contact_postcode
- 
contact_bedrooms
- 
property_condition
- 
callback_requested
- 
callback_time
How the Data Flows After the call ends, Retell AI will send the 
call_analyzed
webhook with this payload [(1) ]() :
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_analysis": {
      "custom_analysis_data": {
        "contact_bathrooms": "2",
        "contact_postcode": "12345",
        "contact_bedrooms": "3"
      }
    }
  }
}
Sympana receives this webhook and writes the values to your GHL custom fields (only if they're empty, as you mentioned) . ## Important Notes Post-Call Analysis fields are NOT populated for calls that were not connected or where no conversation took place . Always check whether the field exists before using it. The custom analysis data only appears in the 
call_analyzed
webhook event, which is the third webhook sent after each call [(3) ]() . Make sure Sympana is configured to process this specific event type. **Bottom line**: Yes, you should configure the Post-Call Analysis prompts/fields in Retell AI with the exact field names Sympana expects (like 
contact_bathrooms
) . This ensures Retell AI extracts the data and sends it via the 
call_analyzed
webhook, which Sympana then writes to GHL.
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Update Voice Agent](https://docs.retellai.com/api-references/update-agent) [[3] Discord message from @keshav3 on 2025-01-30](https://discord.com/channels/1186424376300679209/1186462578310910112/1334444968156332126) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
I already got that figured out. My question is: can I do this, yes or no? For example, can I just create a prompt so Simpana can do this or replace the custom fields and all the stuff, yes or no, and why? How could this happen, how, blah blah blah, and all the things? Not this one. I don't want you to do this one.
@AI Evy I already got that figured out. My question is: can I do this, yes or no? For example, can I just create a prompt so Simpana can do this or replace the custom fields and all the stuff, yes or no, and why? How could this happen, how, blah blah blah, and all the things? Not this one. I don't want you to do this one.
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer No, you cannot configure Sympana's behavior through Retell AI prompts. Retell AI's Post-Call Analysis configuration controls what data Retell AI extracts and sends via webhook [(1) ]() . Sympana Connector is a separate integration platform that receives that webhook data and then writes it to GHL [(2) ]() . The data flow is: 1. Retell AI extracts data based on Post-Call Analysis fields you configure in Retell AI's dashboard [(1) ]() 2. Retell AI sends the 
call_analyzed
webhook containing 
custom_analysis_data
3. Sympana receives that webhook and writes the values to GHL custom fields [(2) ]() Sympana's logic for how it processes the webhook data (what fields it writes, when it writes them, etc.) is controlled by Sympana's configuration, not Retell AI's prompts . **What you control in Retell AI**: The Post-Call Analysis field names, types, and extraction prompts [(1) ]() . **What you don't control in Retell AI**: How Sympana processes that data after receiving it [(2) ]() . If you want to change Sympana's behavior (like which GHL fields it updates or when) , you need to configure that in Sympana's settings, not in Retell AI's agent prompts.
​ To learn more, see the sources I considered: [[1] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) [[2] Sympana Connector | Retell AI APP Partner](https://www.retellai.com/app-partner/sympana) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy now the thing is how to do the callback
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on the available sources, Retell AI does not have a built-in automated callback scheduling feature [(1) ]() [(2) ]() [(3) ]() [(4) ]() [(5) ]() . You'll need to build this workflow externally using GHL or another automation platform. ## How to Implement Callbacks Extract callback information via Post-Call Analysis [(1) ]() [(2) ]() Configure custom Post-Call Analysis fields in your Retell AI agent to capture callback requests: - 
callback_requested
(Boolean) - Whether the user requested a callback - 
callback_time
(Text) - When they want to be called back (e.g., "tomorrow at 2pm", "next week") - 
callback_reason
(Text) - Why they want the callback Receive the data in GHL via webhook [(1) ]() After the call ends, Retell AI sends the 
call_analyzed
webhook with your extracted data:
Copy code
json
{
  "event_type": "call_analyzed",
  "call": {
    "call_analysis": {
      "custom_analysis_data": {
        "callback_requested": true,
        "callback_time": "tomorrow at 2pm",
        "callback_reason": "wants more information"
      }
    }
  }
}
Build the callback automation in GHL In your GHL workflow: 1. Receive the 
call_analyzed
webhook from Retell AI 2. Check if 
callback_requested
is 
true
3. Parse the 
callback_time
to schedule the callback 4. Create a scheduled task or workflow in GHL to trigger a new Retell AI outbound call at that time Retell AI only handles the calling [(6) ]() [(5) ]() - it doesn't schedule or automate when calls happen. You need GHL, Make.com, Zapier, or another automation platform to handle the scheduling logic and trigger new calls.
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer I can see you mentioned "it shows this" but I don't see an error message or screenshot attached to your message. Could you please share what error or issue you're seeing when testing your GoHighLevel and Retell AI function? Once you provide the specific error message or describe what's happening, I can help troubleshoot the issue with your integration. Common issues with GHL + Retell AI integrations include [(1) ]() : - Webhook timeout - Retell AI webhooks have a 10-second timeout and will retry up to 3 times if no success status (2xx) is received - Wrong webhook event - Make sure you're listening for the correct event type (
call_analyzed
for post-call analysis data) [(1) ]() [(2) ]() - Missing webhook subscription - Verify you've subscribed to the events you need in your webhook configuration [(1) ]() Please share the error details and I'll help you resolve it.
​ To learn more, see the sources I considered: [[1] Webhook Overview](https://docs.retellai.com/features/webhook-overview) [[2] Consume the analysis data](https://docs.retellai.com/features/post-call-analysis-consumption) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
It says "Call dispatch accepted for immediate background placement". Instead of calling me I couldn't receive the call and it shows "Call dispatch accepted for immediate background placement" inside GoHigh Level where I triggered the calling using Simpana connector. This screenshot is from the execution logs. @AI Evy
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer The message "Call dispatch accepted for immediate background placement" indicates that GHL successfully queued the call request, but this doesn't mean Retell AI received or processed it [(1) ]() . ## Common Causes and Fixes The Retell call must be initiated from your automation platform, not GHL directly Based on community reports, when using GHL + Sympana + Retell AI, the Retell outbound call trigger should be removed from GHL . Instead, the call should be initiated after your automation platform receives the necessary data . Verify the call actually reached Retell AI Check your Retell AI dashboard's call history. If no call appears there, the request never reached Retell AI's API . Check your phone number configuration If you're calling numbers outside the US with a Retell-purchased number, this won't work [(2) ]() . Retell-purchased numbers can only call US phone numbers . For international calls (like Colombia) , you need to use custom SIP trunking with providers like Twilio or Telnyx . Verify webhook configuration Make sure your webhook is properly configured to receive call events from Retell AI [(3) ]() . The webhook should have a 10-second timeout and will retry up to 3 times if no success status (2xx) is received . ## Next Steps 1. Check if the call appears in your Retell AI dashboard 2. Verify the phone number you're calling is compatible with your Retell number 3. Review your Sympana connector configuration to ensure it's properly triggering Retell AI's API If the issue persists after checking these items, you may need to review your Sympana connector setup or contact their support, as the error message you're seeing is from GHL's execution logs,
not Retell AI.
​ To learn more, see the sources I considered: [[1] GHL + Make + Retell](https://community.retellai.com/t/ghl-make-retell/806) [[2] AI Agent conectado con Go high level no hace llamadas y tiene este error](https://discord.com/channels/1186424376300679209/1378464460741808248) [[3] Webhook Overview](https://docs.retellai.com/features/webhook-overview) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy In the call history in Retell it doesn't show up
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer If the call doesn't appear in Retell AI's call history, the API request never reached Retell AI's servers [(1) ]() . This means the issue is with how GHL or Sympana is triggering the call. ## Troubleshooting Steps Verify your API configuration in Sympana Check that Sympana has the correct Retell AI API key and agent ID configured [(2) ]() . Community members have reported that copying and pasting the agent ID sometimes results in incorrect configuration . Check the API endpoint being called Ensure Sympana is calling the correct Retell AI endpoint. For phone calls, it should be the create-phone-call endpoint, not create-web-call [(1) ]() . Some users have experienced issues where the system was attempting web calls instead of phone calls . Review your phone number setup Verify that your Retell AI number is properly configured and that you're calling a compatible destination number [(3) ]() . If using custom SIP trunking, ensure your origination and termination settings are correct . Test directly with Retell AI API Bypass Sympana temporarily and make a direct API call to Retell AI to verify your credentials and configuration work. This will help isolate whether the issue is with Sympana's integration or your Retell AI setup. Check Sympana's webhook configuration Verify that Sympana's webhook URL is correctly configured to receive responses from Retell AI [(4) ]() . The webhook has a 10-second timeout and will retry up to 3 times if no success status (2xx) is received . If none of these steps resolve the issue, contact Sympan
a support directly, as the problem appears to be with their connector's integration with Retell AI rather than Retell AI itself.
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
​ To learn more, see the sources I considered: [[1] Web Call instead of Phone Call](https://discord.com/channels/1186424376300679209/1462915737013321883) [[2] integrate GHL With Retell](https://discord.com/channels/1186424376300679209/1349283066618712075) [[3] Custom Telephony Overview](https://docs.retellai.com/deploy/custom-telephony) [[4] Webhook Overview](https://docs.retellai.com/features/webhook-overview) ​
z
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer I can see you mentioned "we got this message" but I don't see the actual message content attached to your post. Could you please share what message or error you're seeing? Once you provide the specific message, I can help troubleshoot the issue with your GHL and Sympana connector integration. In the meantime, here are common issues when calls don't appear in Retell AI's call history: API Request Never Reached Retell AI If the call doesn't show in Retell AI's dashboard, the API request didn't reach Retell AI's servers [(1) ]() [(2) ]() . This means the issue is with how Sympana is triggering the call. Common Causes: - Incorrect API key or agent ID in Sympana configuration [(3) ]() - Wrong API endpoint being called (e.g., web call endpoint instead of phone call endpoint) [(1) ]() - Phone number compatibility issues - Webhook timeout or configuration errors [(4) ]() Webhook Specifications: The webhook has a timeout of 10 seconds and will retry up to 3 times if no success status (2xx) is received . When calls don't connect (like 
dial_failed
, 
dial_no_answer
, 
dial_busy
disconnection reasons) , the 
call_started
webhook won't be triggered, but 
call_ended
and 
call_analyzed
webhooks will still fire . Please share the message you're seeing so I can provide more specific guidance.
​ To learn more, see the sources I considered: [[1] Register Phone Call](https://docs.retellai.com/api-references/register-phone-call) [[2] Get Call](https://docs.retellai.com/api-references/get-call) [[3] Sympana Connector | Retell AI APP Partner](https://www.retellai.com/app-partner/sympana) [[4] Webhook Overview](https://docs.retellai.com/features/webhook-overview) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy heres the messagewhen i tried calling direct using retell: Error creating phone call The agent associated with this call failed due to potential of violation of Retell's Terms of Service. Please look for an email from support@retellai.com for more details.
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer The error message you're receiving indicates that your account or agent has been flagged for potential Terms of Service violations [(1) ]() [(2) ]() . This is why calls aren't appearing in your Retell AI call history. ## What This Means Your account appears to have restrictions that prevent calls from being initiated . This is a compliance/security measure by Retell AI, not a technical configuration issue with Sympana or GHL. ## Immediate Action Required Check your email inbox (including spam/junk folders) for a message from support@retellai.com with details about the restriction [(1) ]() . If you haven't received an email, contact support@retellai.com directly with your: - Account email - Agent ID - Organization ID - Description of your use case ## Similar Cases Other users have experienced this same error and needed to request account whitelisting from the Retell support team [(1) ]() [(2) ]() . The support team reviews the account and use case before removing restrictions. This explains why: - Calls don't appear in Retell AI's call history - GHL shows "Call dispatch accepted" but nothing happens - The API request appears to be blocked before reaching Retell's servers You'll need to resolve this account restriction with Retell AI support before you can continue testing your GHL + Sympana integration.
​ To learn more, see the sources I considered: [[1] "Violation of Retell's Terms of Service" - Call Issues. Possible Restriction on My Account](https://discord.com/channels/1186424376300679209/1357734136000938137) [[2] 403 - "{\"status\":\"error\",\"message\":\"The agent associated with this call failed due to potent](https://discord.com/channels/1186424376300679209/1425946158110605474) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
z
@AI Evy what would be the possible cause bcs were just testing the calls
a
Thanks for the follow-up, @Zai. I'll get back to you soon.
### Answer Based on the available sources, I don't have specific documentation about the exact criteria that trigger Terms of Service restrictions during testing. However, I can provide some context about compliance and security measures. Retell AI implements strong compliance and security controls to protect against abuse and ensure adherence to industry regulations [(1) ]() . The platform includes features like scam detection and usage limits to safeguard users [(2) ]() . Common triggers for account restrictions in similar platforms typically include: - Unusual calling patterns or volumes that appear suspicious - Calls to restricted or flagged phone numbers - Content that violates telecom regulations or anti-spam laws - Missing proper consent or compliance documentation - Geographic restrictions (calls to certain countries or regions) Since you mentioned you're "just testing the calls," the restriction might have been triggered by automated fraud detection systems even during legitimate testing . What you should do: Contact support@retellai.com directly with: - Your account details - Agent ID - Explanation that you're conducting legitimate testing - Description of your intended use case The Retell AI support team will review your account and use case to determine if the restriction can be removed. This is a manual review process to ensure the platform remains secure and compliant [(1) ]() . Once your account is whitelisted, you'll be able to proceed with your GHL + Sympana integration testing.
​ To learn more, see the sources I considered: [[1] Compliance](https://www.retellai.com/glossary/compliance) [[2] Platform Changelogs | Retell AI](https://www.retellai.com/changelog) ​
Feel free to tag @AI Evy with additional questions. I also appreciate feedback, it helps me improve.
PreviousNext
Powered by