Elite Voice Agents

Tag: Voice automation

Tutorial – How to Use the Inbound Call Webhook & Dynamic Variables in Retell AI!
In “Tutorial – How to Use the Inbound Call Webhook & Dynamic Variables in Retell AI!” Henryk Brzozowski shows how Retell AI now lets you pick which voice agent handles inbound calls so you can adapt behavior by time of day, CRM conditions, country code, state, and other factors. This walkthrough explains why that control matters and how it helps you tailor responses and routing for smoother automation.

The video lays out each step with timestamps—from a brief overview and use-case demo to how the system works, securing the webhook, dynamic variables, and template setup—so you can jump to the segments that matter most to your use case. Follow the practical examples to configure agent selection and integrate the webhook into your workflows with confidence.

Overview of the Inbound Call Webhook in Retell AI

The inbound call webhook in Retell AI is the mechanism by which the platform notifies your systems the moment a call arrives and asks you how to handle it. You use this webhook to decide which voice agent should answer, what behavior that agent should exhibit, and whether to continue, transfer, or terminate the call. Think of it as the handoff point where Retell gives you full control to apply business logic and data-driven routing before the conversation begins.

Purpose and role of the inbound call webhook in Retell AI

The webhook’s purpose is to let you customize call routing and agent behavior dynamically. Instead of relying on a static configuration inside the Retell dashboard, you receive a payload describing the incoming call and any context (CRM metadata, channel, caller ID, etc.), and you respond with the agent choice and instructions. This enables complex, real-time decisions that reflect your business rules, CRM state, and contextual data.

High-level flow from call arrival to agent selection

When a call arrives, Retell invokes your configured webhook with a JSON payload that describes the call. Your endpoint processes that payload, applies your routing logic (time-of-day checks, CRM lookup, geographic rules, etc.), chooses an agent or fallback, and returns a response instructing Retell which voice agent to spin up and which dynamic variables or template to use. Retell then launches the selected agent and begins the voice interaction according to your returned configuration.

How the webhook interacts with voice agents and the Retell platform

Your webhook never has to host the voice agent itself — it simply tells Retell which agent to instantiate and what context to pass to it. The webhook can return agent ID, template ID, dynamic variables, and other metadata. Retell will merge your response with its internal routing logic, instantiate the chosen voice agent, and pass along the variables to shape prompts, tone, and behavior. If your webhook indicates termination or transfer, Retell will act accordingly (end the call, forward it, or hand it to a fallback).

Key terminology: webhook, agent, dynamic variable, payload
- Webhook: an HTTP endpoint you own that Retell calls to request routing instructions for an inbound call.
- Agent: a Retell voice AI persona or model configuration that handles the conversation (prompts, voice, behavior).
- Dynamic variable: a key/value that you pass to agents or templates to customize behavior (for example, greeting text, lead score, timezone).
- Payload: the JSON data Retell sends to your webhook describing the incoming call and associated metadata.
Use Cases and Demo Scenarios

This section shows practical situations where the inbound call webhook and dynamic variables add value. You’ll see how to use real-time context and external data to route calls intelligently.

Common business scenarios where inbound call webhook adds value

You’ll find the webhook useful for support routing, sales qualification, appointment confirmation, fraud prevention, and localized greetings. For example, you can route high-value prospects to senior sales agents, send calls outside business hours to voicemail or an after-hours agent, or present a customized script based on CRM fields like opportunity stage or product interest.

Time-of-day routing example and expected behavior

If a call arrives outside your normal business hours, your webhook can detect the timestamp and return a response that routes the call to an after-hours agent, plays a recorded message, or schedules a callback. Expected behavior: during business hours the call goes to live sales agents; after-hours the caller hears a friendly voice agent that offers call-back options or collects contact info.

CRM-driven routing example using contact and opportunity data

When Retell sends the webhook payload, include or look up the caller’s phone number in your CRM. If the contact has an open opportunity with high value or “hot” status, your webhook can choose a senior or specialized agent and pass dynamic variables like lead score and account name. Expected behavior: high-value leads get premium handling and personalized scripts drawn from your CRM fields.

Geographic routing example using country code and state

You can use the caller’s country code or state to route to local-language agents, region-specific teams, or to apply compliance scripts. For instance, callers from a specific country can be routed to a local agent with the appropriate accent and legal disclosures. Expected behavior: localized greetings, time-sensitive offers, and region-specific compliance statements.

Hybrid scenarios: combining business rules, CRM fields, and time

Most real-world flows combine multiple factors. Your webhook can first check time-of-day, then consult CRM for lead score, and finally apply geographic rules. For example, during peak hours route VIP customers to a senior agent; outside those hours route VIPs to an on-call specialist or schedule a callback. The webhook lets you express these layered rules and return the appropriate agent and variables.

How Retell AI Selects Agents

Understanding agent selection helps you design clear, predictable routing rules.

Agent types and capabilities in Retell AI

Retell supports different kinds of agents: scripted assistants, generative conversational agents, language/localization variants, and specialized bots (support, sales, compliance). Each agent has capabilities like voice selection, prompt templates, memory, and access to dynamic variables. You select the right type based on expected conversation complexity and required integrations.

Decision points that influence agent choice

Key decision points include call context (caller ID, callee number), time-of-day, CRM status (lead score, opportunity stage), geography (country/state), language preference, and business priorities (VIP escalation). Your webhook evaluates these to pick the best agent.

Priority, fallback, and conditional agent selection

You’ll typically implement a priority sequence: try the preferred agent first, then a backup, and finally a fallback agent that handles unexpected cases. Conditionals let you route specific calls (e.g., high-priority clients go to Agent A unless Agent A is busy, then Agent B). In your webhook response you can specify primary and fallback agents and even instruct Retell to try retries or route to voicemail.

How dynamic variables feed into agent selection logic

Dynamic variables carry the decision context: caller language, lead score, account tier, local time, etc. Your webhook either receives these variables in the inbound payload or computes/fetches them from external systems and returns them to Retell. The agent selection logic reads these variables and maps them to agent IDs, templates, and behavior modifiers.

Anatomy of the Inbound Call Webhook Payload

Familiarity with the payload fields ensures you know where to find crucial routing data.

Typical JSON structure received by your webhook endpoint

Retell sends a JSON object that usually includes call identifiers, timestamps, caller and callee info, and metadata. A simplified example looks like: { “call_id”: “abc123”, “timestamp”: “2025-01-01T14:30:00Z”, “caller”: { “number”: “+15551234567”, “name”: null }, “callee”: { “number”: “+15557654321” }, “metadata”: { “crm_contact_id”: “c_789”, “campaign”: “spring_launch” } } You’ll parse this payload to extract the fields you need for routing.

Important fields to read: caller, callee, timestamp, metadata

The caller.number is your primary key for CRM lookups and geolocation. The callee.number tells you which of your numbers was dialed if you own multiple lines. Timestamp is critical for time-based routing. Metadata often contains Retell-forwarded context, like the source campaign or previously stored dynamic variables.

Where dynamic variables appear in the payload

Retell includes dynamic variables under a metadata or dynamic_variables key (naming may vary). These are prepopulated by previous steps in your flow or by the dialing source. Your webhook should inspect these and may augment or override them before returning your response.

Custom metadata and how Retell forwards it

If your telephony provider or CRM adds custom tags, Retell will forward them in metadata. That allows you to carry contextual info — like salesperson ID or campaign tags — from the dialing source through to your routing logic. Use these tags for more nuanced agent selection.

Configuring Your Webhook Endpoint

Practical requirements and response expectations for your endpoint.

Required endpoint characteristics (HTTPS, reachable public URL)

Your endpoint must be a publicly reachable HTTPS URL with a valid certificate. Retell needs to POST data to it in real time, so it must be reachable from the public internet and respond timely. Local testing can be done with tunneling tools, but production endpoints should be resilient and hosted with redundancy.

Expected request headers and content types

Retell will typically send application/json content with headers indicating signature or authentication metadata (for example X-Retell-Signature or X-Retell-Timestamp). Inspect headers for authentication and use standard JSON parsing to handle the body.

How to respond to Retell to continue or terminate flow

Your response instructs Retell what to do next. To continue the flow, return a JSON object that includes the selected agent_id, template_id, and any dynamic_variables you want applied. To terminate or transfer, return an action field indicating termination, voicemail, or transfer target. If you can’t decide, return a fallback agent or an explicit error. Retell expects clear action directives.

Recommended response patterns and status codes

Return HTTP 200 with a well-formed JSON body for successful routing decisions. Use 4xx codes for client-side issues (bad request, unauthorized) and 5xx for server errors. If you return non-2xx, Retell may retry or fall back to default behavior; document and test how your configuration handles retries. Include an action field in the 200 response to avoid ambiguity.

Local development options: tunneling with ngrok and similar tools

For development, use ngrok or similar tunneling services to expose your local server to Retell. That lets you iterate quickly and inspect incoming payloads. Remember to secure your dev endpoint with temporary secrets and disable public tunnels after testing.

Securing the Webhook

Security is essential — you’re handling PII and controlling call routing.

Authentication options: shared secret, HMAC signatures, IP allowlist

Common options include a shared secret used to sign payloads (HMAC), a signature header you validate, and IP allowlists at your firewall to accept requests only from Retell IPs. Use a combination: validate HMAC signatures and maintain an IP allowlist for defense-in-depth.

How to validate the signature and protect against replay attacks

Retell can include a timestamp header and an HMAC signature computed over the body and timestamp. You should compute your own HMAC using the shared secret and compare in constant time. To avoid replay, accept signatures only if the timestamp is within an acceptable window (for example, 60 seconds) and maintain a short-lived nonce cache to detect duplicates.

Transport security: TLS configuration and certificate recommendations

Use strong TLS (currently TLS 1.2 or 1.3) with certificates from a trusted CA. Disable weak ciphers and ensure your server supports OCSP stapling and modern security headers. Regularly test your TLS configuration against best-practice checks.

Rate-limiting, throttling, and handling abusive traffic

Implement rate-limiting to avoid being overwhelmed by bursts or malicious traffic. Return a 429 status for client-side throttling and consider exponential backoff on retries. For abusive traffic, block offending IPs and alert your security team.

Key rotation strategies and secure storage of secrets

Rotate shared secrets on a schedule (for example quarterly) and keep a migration window to support both old and new keys during transition. Store secrets in secure vaults or environment managers rather than code or plaintext. Log and audit key usage where possible.

Dynamic Variables: Concepts and Syntax

Dynamic variables are the glue between your data and agent behavior.

Definition and purpose of dynamic variables in Retell

Dynamic variables are runtime key/value pairs that you pass into templates and agents to customize their prompts, behavior, and decisions. They let you personalize greetings, change script branches, and tailor agent tone without creating separate agent configurations.

Supported variable types and data formats

Retell supports strings, numbers, booleans, timestamps, and nested JSON-like objects for complex data. Use consistent formats (ISO 8601 for timestamps, E.164 for phone numbers) to avoid parsing errors in templates and agent logic.

Variable naming conventions and scoping rules

Use clear, lowercase names with underscores (for example lead_score, caller_country). Keep scope in mind: some variables are global to the call session, while others are template-scoped. Avoid collisions by prefixing custom variables (e.g., crm_lead_score) if Retell reserves common names.

How to reference dynamic variables in templates and routing rules

In templates and routing rules you reference variables using the platform’s placeholder syntax (for example {}). Use variables to customize spoken text, conditional branches, and agent selection logic. Ensure you escape or validate values before injecting them into prompts to avoid unexpected behavior.

Precedence rules when multiple variables overlap

When a variable is defined in multiple places (payload metadata, webhook response, template defaults), Retell typically applies a precedence order: explicit webhook-returned variables override payload-supplied variables, which override template defaults. Understand and test these precedence rules so you know which value wins.

Using Dynamic Variables to Route Calls

Concrete examples of variable-driven routing.

Examples: routing by time of day using variables

Compute local time from timestamp and caller timezone, then set a variable like business_hours = true/false. Use that variable to choose agent A (during hours) or agent B (after hours), and pass a greeting_time variable to the script so the agent can say “Good afternoon” or “Good evening.”

Examples: routing by CRM status or lead score

After receiving the call, do a CRM lookup based on caller number and return variables such as lead_score and opportunity_stage. If lead_score > 80 return agent_id = “senior_sales” and dynamic_variables.crm_lead_score = 95; otherwise return agent_id = “standard_sales.” This direct mapping gives you fine control over escalation.

Examples: routing by caller country code or state

Parse caller.number to extract the country code and set dynamic_variables.caller_country = “US” or dynamic_variables.caller_state = “CA”. Route to a localized agent and pass a template variable to include region-specific compliance text or offers tailored to that geography.

Combining multiple variables to create complex routing rules

Create compound rules like: if business_hours AND lead_score > 70 AND caller_country == “US” route to senior_sales; else if business_hours AND lead_score > 70 route to standard_sales; else route to after_hours_handler. Your webhook evaluates these conditions and returns the corresponding agent and variables.

Fallbacks and default variable values for robust routing

Always provide defaults for critical variables (for example lead_score = 0, caller_country = “UNKNOWN”) so agents can handle missing data. Include fallback agents in your response to ensure calls aren’t dropped if downstream systems fail.

Templates and Setup in Retell AI

Templates translate variables and agent logic into conversational behavior.

How templates use dynamic variables to customize agent behavior

Templates contain prompts with placeholders that get filled by dynamic variables at runtime. For example, a template greeting might read “Hello {}, this is {} calling about your {}.” Variables let one template serve many contexts without duplication.

Creating reusable templates for common call flows

Design templates for common flows like lead qualification, appointment confirmation, and support triage. Keep templates modular and parameterized so you can reuse them across agents and campaigns. This reduces duplication and accelerates iteration.

Configuring agent behavior per template: prompts, voice, tone

Each template can specify the agent prompt, voice selection, speech rate, and tone. Use variables to fine-tune the pitch and script content for different audiences: friendly or formal, sales or support, concise or verbose.

Steps to deploy and test a template in Retell

Create the template, assign it to a test agent, and use staging numbers or ngrok endpoints to simulate inbound calls. Test edge cases (missing variables, long names, unexpected characters) and verify how the agent renders the filled prompts. Iterate until you’re satisfied, then promote the template to production.

Managing templates across environments (dev, staging, prod)

Maintain separate templates or version branches per environment. Use naming conventions and version metadata so you know which template is live where. Automate promotion from staging to production with CI/CD practices when possible, and test rollback procedures.

Conclusion

A concise wrap-up and next steps to get you production-ready.

Recap of key steps to implement inbound call webhook and dynamic variables

To implement this system: expose a secure HTTPS webhook, parse the inbound payload, enrich with CRM and contextual data, evaluate your routing rules, return an agent selection and dynamic variables, and test thoroughly across scenarios. Secure the webhook with signatures and rate-limiting and plan for fallbacks.

Final best practice checklist before going live

Before going live, verify: HTTPS with strong TLS, signature verification implemented, replay protection enabled, fallback agent configured, template defaults set, CRM lookups performant, retry behavior tested, rate limits applied, and monitoring/alerting in place for errors and latency.

Next steps for further customization and optimization

After launch, iterate on prompts and routing logic based on call outcomes and analytics. Add more granular variables (customer lifetime value, product preferences). Introduce A/B testing of templates and collect agent performance metrics to optimize routing. Automate key rotation and integrate monitoring dashboards.

Pointers to Retell AI documentation and community resources

Consult the Retell AI documentation for exact payload formats, header names, and template syntax. Engage with the community and support channels provided by Retell to share patterns, get examples, and learn best practices from other users. These resources will speed your implementation and help you solve edge cases efficiently.

You’re now equipped to design an inbound call webhook that uses dynamic variables to select agents intelligently and securely. Start with simple rules, test thoroughly, and iterate — you’ll be routing calls with precision and personalization in no time.

If you want to implement Chat and Voice Agents into your business to reduce missed calls, book more appointments, save time, and make more revenue, book a discovery call here: https://brand.eliteaienterprises.com/widget/bookings/elite-ai-30-min-demo-call
December 23, 2025
Training AI with VAPI and Make.com for Fitness Calls

In “Training AI with VAPI and Make.com for Fitness Calls,” you get a friendly, practical walkthrough from Henryk Brzozowski that shows an AI posing as a personal trainer and the learning moments that follow. You’ll see how he approaches the experiment, sharing clear examples and outcomes so you can picture how the setup might work for your projects.

The video moves from a playful AI trainer call into a more serious fitness conversation, then demonstrates integrating VAPI with the no-code Make.com platform to capture and analyze call transcripts. You’ll learn step-by-step how to set up the automation, review timestamps for key moments, and take away next steps to apply the workflow yourself.

Project objectives and success metrics

You should start by clearly stating why you are training AI to handle fitness calls and what success looks like. This section gives you a concise view of high-level aims and the measurable outcomes you will use to evaluate progress. By defining these upfront, you keep the project focused and make it easier to iterate based on data.

Define primary goals for training AI to handle fitness calls

Your primary goals should include delivering helpful, safe, and personalized guidance to callers while automating routine interactions. Typical goals: capture accurate intake information, provide immediate workout recommendations or scheduling, escalate medical or safety concerns, and collect clean transcripts for analytics and coaching improvement. You also want to reduce human trainer workload by automating common follow-ups and improve conversion from call to paid plans.

List measurable KPIs such as call-to-plan conversion rate, transcription accuracy, and user satisfaction

Define KPIs that map directly to your goals. Measure call-to-plan conversion rate (percentage of calls that convert to a workout plan or subscription), average call length, first-call resolution for scheduling or assessments, transcription accuracy (word error rate, WER), intent recognition accuracy, user satisfaction scores (post-call NPS or CSAT), and safety escalation rate (number of calls correctly flagged for human intervention). Track cost-per-call and average time saved per call as operational KPIs.

Establish success criteria for persona fidelity and response relevance

Set objective thresholds for persona fidelity—how closely the AI matches the trainer voice and style—and response relevance. For instance, require that 90% of sampled calls score above a fidelity threshold on human review, or that automated relevance scoring (semantic similarity between expected and actual responses) meets a defined cutoff. Also define acceptable error rates for safety-critical advice; any advice that may harm users should trigger human review.

Identify target users and sample user stories for different fitness levels

Identify who you serve: beginners wanting guidance, intermediate users refining programming, advanced athletes optimizing performance, and users with special conditions (pregnancy, rehab). Create sample user stories: “As a beginner, you want a gentle 30-minute plan with minimal equipment,” or “As an injured runner, you need low-impact alternatives and clearance advice.” These stories guide persona conditioning and branching logic in conversations.

Outline short-term milestones and long-term roadmap

Map out short-term milestones: prototype an inbound call flow, capture and transcribe 100 test calls, validate persona prompts with 20 user interviews, and achieve baseline transcription accuracy. Long-term roadmap items include multi-language support, full real-time coaching with audio feedback, integration with wearables and biometrics, compliance and certification for medical-grade advice, and scaling to thousands of concurrent calls with robust analytics and dashboards.

Tools and components overview

You need a clear map of the components that will power your fitness call system. This overview helps you choose which pieces to prototype first and how they will work together.

Describe VAPI and the functionality it provides for voice calls and AI-driven responses

VAPI provides the voice API layer for creating, controlling, and interacting with voice sessions. You can use it to initiate outbound calls, accept inbound connections, stream or record audio, and inject or capture AI-driven responses. VAPI acts as the audio and session orchestration engine, enabling you to combine telephony, transcription, and generative AI in real time or via post-call processing.

Explain Make.com (Make) as the no-code automation/orchestration layer

Make (Make.com) is your no-code automation platform to glue services together without writing a full backend. You use Make to create scenarios that listen to VAPI webhooks, fetch recordings, call transcription services, branch logic based on intent, store data in spreadsheets or databases, and trigger downstream actions like emailing summaries or updating CRM entries. Make reduces development time and lets non-developers iterate on flows.

Identify telephony and recording options (SIP, Twilio, Plivo, PSTN gateways)

For telephony and recording you have multiple options: SIP trunks for on-prem or cloud PBX integration, cloud telephony providers like Twilio or Plivo that manage numbers and PSTN connectivity, and PSTN gateways for legacy integrations. Choose a provider that supports recording, webhooks for event notifications, and the codec/sample rate you need. Consider provider pricing, regional availability, and compliance requirements like call recording consent.

Compare transcription engines and models (real-time vs batch) and where they fit

Transcription choices fall into real-time low-latency ASR and higher-accuracy batch transcription. Real-time ASR (WebRTC or streaming APIs) fits scenarios where live guidance or immediate intent detection is needed. Batch transcription suits post-call analysis where you can use larger models or additional cleanup steps for higher accuracy. Evaluate options on latency, accuracy for accents, cost, speaker diarization, and punctuation. You may combine both: a fast real-time model for intent routing and a higher-accuracy batch pass for analytics.

List data storage, analytics, and dashboarding tools (Google Sheets, Airtable, BI tools)

Store raw and processed data in places that match your scale and query needs: Google Sheets or Airtable for small-scale operational data and fast iteration; cloud databases like BigQuery or PostgreSQL for scale; object storage for audio files. For analytics and dashboards, use BI tools such as Looker, Tableau, Power BI, or native dashboards in your data warehouse. Instrument event streams for metrics feeding your dashboards and alerts.

Account setup and credential management

Before you build, set up accounts and credentials carefully. This ensures secure and maintainable integration across VAPI, Make, telephony, and transcription services.

Steps to create and configure a VAPI account and obtain API keys

Create a VAPI account through the provider’s onboarding flow, verify your identity as required, and provision API keys for development and production. Generate scoped keys: one for session control and another read-only key for analytics if supported. Record base endpoints and webhook URLs you will register with telephony providers. Apply rate limits or usage alerts to your keys.

Register a Make.com account and enable necessary modules and connections

Sign up for Make and select a plan that supports the number of operations and scenarios you expect. Enable modules or connectors you need—HTTP calls, webhooks, Google Sheets/Airtable, and your chosen transcription module if available. Create a workspace for the project and set naming conventions for scenarios to keep things organized.

Provision telephony/transcription provider accounts and configure webhooks

On your telephony provider, buy numbers or configure SIP trunks, enable call recording, and register webhook URLs that point to your Make webhooks or your middleware. For transcription providers, create API credentials and set callback endpoints for asynchronous processing if applicable. Test end-to-end flow with a sandbox number before production.

Best practices for storing secrets and API keys securely in Make and environment variables

Never hard-code API keys in scenarios or shared documents. Store secrets using secure vault features or environment variables Make provides, or use a secrets manager and reference them dynamically. Limit key scope and rotate keys periodically. Log only the minimal info needed for debugging; scrub sensitive data from logs.

Setting up role-based access control and audit logging

Set up RBAC so only authorized team members can change scenarios or access production keys. Use least-privilege principles for accounts and create service accounts for automated flows. Enable audit logging to capture changes, access events, and credential usage so you can trace incidents and ensure compliance.

Designing the fitness call flow

A well-designed call flow ensures consistent interactions and reliable data capture. You will map entry points, stages, consent, branching, and data capture points.

Define call entry points and routing logic (incoming inbound calls, scheduled outbound calls)

Define how calls start: inbound callers dialing your number, scheduled outbound calls triggered by reminders or sales outreach, or callbacks requested via web forms. Route calls based on intent detection from IVR choices, account status (existing client vs prospect), or time of day. Implement routing to human trainers for high-risk cases or when AI confidence is low.

Map conversation stages: greeting, fitness assessment, workout recommendation, follow-up

Segment the interaction into stages. Start with a friendly greeting and consent prompt, then a fitness assessment with questions about goals, experience, injuries, and equipment. Provide a tailored workout recommendation or schedule a follow-up coaching session. End with a recap, next steps, and optional feedback collection.

Plan consent and disclosure prompts before recording calls

Include a clear consent prompt before recording or processing calls: state that the call will be recorded for quality and coaching, explain data usage, and offer an opt-out path. Log consent choices in metadata so you can honor deletion or non-recording requests. Ensure the prompt meets legal and regional compliance requirements.

Design branching logic for different user intents and emergency escalation paths

Build branching for major intents: workout planning, scheduling, injury reports, equipment questions, or billing. Include an emergency escalation path if the user reports chest pain, severe shortness of breath, or other red flags—immediately transfer to human support and log the escalation. Use confidence thresholds to route low-confidence or ambiguous cases to human review.

Specify data capture points: metadata, biometric inputs, explicit user preferences

Decide what you capture at each stage: caller metadata (phone, account ID), self-reported biometrics (height, weight, age), fitness preferences (workout duration, intensity, equipment), and follow-up preferences (email, SMS). Store timestamps and call context so you can reconstruct interactions for audits and personalization.

Crafting the AI personal trainer persona

Your AI persona defines tone, helpfulness, and safety posture. Design it deliberately so users get a consistent and motivating experience.

Define tone, energy level, and language style for the trainer voice

Decide whether the trainer is upbeat and motivational, calm and clinical, or pragmatic and no-nonsense. Define energy level per user segment—high-energy for athletes, gentle for beginners. Keep language simple, encouraging, and jargon-free unless the user signals advanced knowledge. Use second-person perspective to make it personal (“You can try…”).

Create system prompts and persona guidelines for consistent responses

Write system prompts that anchor the AI: specify the trainer’s role, expertise boundaries, and how to respond to common queries. Include examples of preferred phrases, greetings, and how to handle uncertainty. Keep the persona guidelines version-controlled so you can iterate on tone and content.

Plan personalization variables (user fitness level, injuries, equipment) and how they influence responses

Store personalization variables in user profiles and reference them during calls. If the user is a beginner, suggest simpler progressions and lower volume. Flag injuries to avoid specific movements and recommend consults if needed. Adjust recommendations based on available equipment—bodyweight, dumbbells, or gym access.

Handle sensitive topics and safety recommendations with guarded prompts

Tell the AI to avoid definitive medical advice; instead, recommend that the user consult a healthcare professional for medical concerns or new symptoms. For safety, require the AI to ask clarifying questions and to escalate when necessary. Use guarded prompts that prioritize conservative recommendations when the AI is unsure.

Define fallback strategies when the AI is uncertain or user requests specialist advice

Create explicit fallback actions: request clarification, transfer to a human trainer, schedule a follow-up, or provide vetted static resources and disclaimers. When the user asks for specialist advice (nutrition for chronic disease, physical therapy), the AI should acknowledge limitations and arrange human intervention.

Integrating VAPI with Make.com

You will integrate VAPI and Make to orchestrate call flow, data capture, and processing without heavy backend work.

Set up Make webhooks to receive call events and recordings from VAPI

Create Make webhooks that VAPI can call for events such as session started, recording available, or DTMF input. In your Make scenario, parse incoming webhook payloads to trigger downstream modules like transcription or database writes. Test webhooks with sample payloads before going live.

Configure HTTP modules in Make to call VAPI endpoints for session control and real-time interactions

Use Make’s HTTP modules to call VAPI endpoints: initiate calls, inject TTS or audio prompts, stop recordings, or fetch session metadata. For real-time interactions, you may use HTTP streaming or long-polling endpoints depending on VAPI capabilities. Ensure headers and auth are managed securely via environment variables.

Decide between streaming audio to VAPI or uploading recorded files for processing

Choose streaming audio when you need immediate transcription or real-time intent detection. Use upload/post-call processing when you prefer higher-quality batch transcription and can tolerate latency. Streaming is more complex but enables live coaching; batch is simpler and often cheaper for analytics.

Map required request and response fields between VAPI and Make modules

Define the exact JSON fields you exchange: session IDs, call IDs, correlation IDs, audio URLs, timestamps, and user metadata. Map VAPI’s event schema to Make variables so modules downstream can reliably find recording URLs, audio formats, and status flags.

Implement idempotency and correlation IDs to track call sessions across systems

Attach a correlation ID to every call and propagate it through webhooks, transcription jobs, and storage records. Use idempotency keys when triggering retries to avoid duplicate processing. This ensures you can trace a single call across VAPI, Make, transcription services, and analytics.

Building a no-code automation scenario in Make.com

With architecture and integrations mapped, you can build robust no-code scenarios to automate the call lifecycle.

Create triggers for incoming call events and scheduled outbound calls

Create scenarios that trigger on Make webhooks for inbound events and schedule modules for outbound calls or reminders. Use filters to selectively process events — for example, only process recorded calls or only kick off outbound calls for users in a certain timezone.

Chain modules for audio retrieval, transcription, and post-processing

After receiving a recording URL from VAPI, chain modules to fetch the audio, call a transcription API, and run post-processing steps like entity extraction or sentiment analysis. Use data stores to persist intermediate results and ensure downstream steps have what they need.

Use filters, routers, and conditional logic to branch based on intent or user profile

Leverage Make routers and filters to branch flows: route scheduling intent to calendar modules, workout intent to plan generation modules, and injury reports to escalation modules. Apply user profile checks to customize responses or route to different human teams.

Add error handlers, retries, and logging modules for robustness

Include error handling paths that retry transient failures, escalate persistent errors, and log detailed context for debugging. Capture error codes from APIs and store failure rates on dashboards so you can identify flaky integrations.

Schedule scenarios for batch processing of recordings and nightly analysis

Schedule scenarios to run nightly jobs that reprocess recordings with higher-accuracy models, compute daily KPIs, and populate dashboards. Batch processing lets you run heavy NLP tasks during off-peak hours and ensures analytics reflect the most accurate transcripts.

Capturing and transcribing calls

High-quality audio capture and smart transcription choices form the backbone of trustworthy automation and analytics.

Specify recommended audio formats, sampling rates, and quality settings for reliable transcription

Capture audio in lossless or high-bitrate formats: 16-bit PCM WAV at 16 kHz is a common baseline for speech recognition; 44.1 kHz may be used if you also want music fidelity. Use mono channels when possible for speech clarity. Preserve original recordings for reprocessing.

Choose between real-time streaming transcription and post-call transcription workflows

Use real-time streaming if you need immediate intent detection and live interaction. Choose post-call batch transcription for higher-accuracy processing and advanced NLP. Many deployments use a hybrid approach—real-time for routing, batch for analytics and plan creation.

Implement timestamped transcripts for mapping exercise guidance to specific audio segments

Request timestamped transcripts so you can map exercise cues to audio segments. This enables features like clickable playback in dashboards and time-aligned feedback for video or voice overlays when you later produce coaching clips.

Assign speaker diarization or speaker labels to separate trainer and user utterances

Enable speaker diarization to separate trainer and user speech. If diarization is imperfect, use heuristics like voice activity and turn-taking or pass in expected speaker roles for better labeling. Accurate speaker labels are crucial for extracting user-reported metrics and trainer instructions.

Ensure audio retention policy aligns with privacy and storage costs

Define retention windows for raw audio and transcripts that balance compliance, user expectations, and storage costs. For example, keep raw files for 90 days unless the user opts in to allow longer storage. Provide easy deletion paths tied to user consent and privacy requirements.

Processing and analyzing transcripts

Once you have transcripts, transform them into structured, actionable data for personalization and product improvement.

Normalize and clean transcripts (remove filler, normalize units, correct contractions)

Run cleaning steps: remove fillers, standardize units (lbs to kg), expand or correct contractions, and normalize domain-specific phrases. This reduces noise for downstream entity extraction and improves summary quality.

Extract structured entities: exercises, sets, reps, weights, durations, rest intervals

Use NLP to extract structured entities like exercise names, sets, reps, weights, durations, and rest intervals. Map ambiguous or colloquial terms to canonical exercise IDs in your taxonomy so recommendations and progress tracking are consistent.

Detect intents such as goal setting, injury reports, progress updates, scheduling

Run intent classification to identify key actions: defining goals, reporting pain, asking to reschedule, or seeking nutrition advice. Tag segments of the transcript so automation can trigger the correct follow-up actions and route to specialists when needed.

Perform sentiment analysis and confidence scoring to flag low-confidence segments

Add sentiment analysis to capture user mood and motivation, and compute model confidence scores for critical extracted items. Low-confidence segments should be flagged for human review or clarified with follow-up messages.

Generate concise conversation summaries and actionable workout plans

Produce concise summaries that highlight user goals, constraints, and the recommended plan. Translate conversation data into an actionable workout plan with clear progressions, equipment lists, and next steps that you can send via email, SMS, or populate in a coach dashboard.

Conclusion

You should now have a clear path to building AI-driven fitness calls using VAPI and Make as the core building blocks. The overall approach balances immediacy and safety, enabling you to prototype quickly and scale responsibly.

Recap key takeaways for training AI using VAPI and Make.com for fitness calls

You learned to define measurable goals, choose the right telephony and transcription approaches, design safe conversational flows, create a consistent trainer persona, and integrate VAPI with Make for no-code orchestration. Emphasize consent, data security, fallback strategies, and robust logging throughout.

Provide a practical checklist to move from prototype to production

Checklist for you: (1) define KPIs and sample user stories, (2) provision VAPI, Make, and telephony accounts, (3) implement core call flows with consent and routing, (4) capture and transcribe recordings with timestamps and diarization, (5) build persona prompts and guarded safety responses, (6) set up dashboards and monitoring, (7) run pilot with real users, and (8) iterate based on data and human reviews.

Recommend next steps: pilot with real users, iterate on prompts, and add analytics

Start with a small pilot of real users to validate persona and KPIs, then iterate on prompts and branching logic using actual transcripts and feedback. Gradually add analytics and automation, such as nightly reprocessing and coach review workflows, to improve accuracy and trust.

Point to learning resources and templates to accelerate implementation

Gather internal templates for prompts, call flow diagrams, consent scripts, and Make scenario patterns to accelerate rollout. Use sample transcripts to build and test entity extraction rules and to tune persona guidelines. Keep iterating—real user conversations will teach you the most about what works.

By following these steps, you can build a friendly, safe, and efficient AI personal trainer experience that scales and improves over time. Good luck—enjoy prototyping and refining your AI fitness calls!

If you want to implement Chat and Voice Agents into your business to reduce missed calls, book more appointments, save time, and make more revenue, book a discovery call here: https://brand.eliteaienterprises.com/widget/bookings/elite-ai-30-min-demo-call

December 14, 2025
Build an AI Real Estate Cold Caller in 10 minutes | Vapi Tutorial For Beginners

Join us for a fast, friendly guide to Build an AI Real Estate Cold Caller in 10 minutes | Vapi Tutorial For Beginners, showing how to spin up an AI cold calling agent quickly and affordably. This short overview highlights a step-by-step approach to personalize data for better lead conversion.

Let’s walk through the tools, setting up Google Sheets, configuring JSONaut and Make, testing the caller, and adding extra goodies to polish performance, with clear timestamps so following along is simple.

Article Purpose and Expected Outcome

We will build a working AI real estate cold caller that can read lead data from a Google Sheet, format it into payloads, hand it to a Vapi conversational agent, and place calls through a telephony provider — all orchestrated with Make and JSONaut. By the end, we will have a minimal end-to-end flow that dials leads, speaks a tailored script, handles a few basic objections, and writes outcomes back to our sheet so we can iterate quickly.

Goal of the tutorial and what readers will build by the end

Our goal is to give a complete, practical walkthrough that turns raw lead rows into real phone calls within about ten minutes of setup for experienced beginners. We will build a template Google Sheet, a JSONaut transformer to produce Vapi-compatible JSON, a Make scenario to orchestrate triggers and API calls, and a configured Vapi agent with a friendly real estate persona and TTS voice ready to call prospects.

Target audience and prerequisites for following along

We are targeting real estate professionals, small agency operators, and automation-minded builders who are comfortable with basic web apps and API keys. Prerequisites include accounts on Vapi, Google, JSONaut, and Make, basic familiarity with Google Sheets, and a telephony provider account for outbound calls. Familiarity with JSON and simple HTTP push/pull logic will help but is not required.

Estimated time commitment and what constitutes the ten minute build

We estimate the initial build can be completed in roughly ten minutes once accounts and API keys are at hand. The ten minute build means: creating the sheet, copying a template payload, wiring JSONaut, building the simple Make scenario, and testing one call through Vapi using sample data. Fine-tuning scripts, advanced branching, and production hardening will take additional time.

High-level architecture of the AI cold caller system

At a high level, our system reads lead rows from Google Sheets, converts rows to JSON via JSONaut, passes structured payloads to Vapi which runs the conversational logic and TTS, and invokes a telephony provider (or Vapi’s telephony integration) to place calls. Make orchestrates the entire flow, handles authentication between services, updates call statuses back into the sheet, and applies rate limiting and scheduling controls.

Tools and Services You Will Use

We will describe the role of each tool so we understand why each piece is necessary and how they fit together.

Overview of Vapi and why it is used for conversational AI agents

We use Vapi as the conversational AI engine that interprets prompts, manages multi-turn dialogue, and outputs audio or text for calls. Vapi provides agent configuration, persona controls, and integrations for TTS and telephony, making it a purpose-built choice for quickly prototyping and running conversational outbound voice agents.

Role of Google Sheets as a lightweight CRM and data source

Google Sheets functions as our lightweight CRM and single source of truth for contacts, properties, and call metadata. It is easy to update, share, and integrate with automation tools, and it allows us to iterate on lead lists without deploying a database or more complex CRM during early development.

Introduction to JSONaut and its function in formatting API payloads

JSONaut is the transformer that maps spreadsheet rows into the JSON structure Vapi expects. It lets us define templated JSON with placeholders and simple logic so we can handle default values, conditional fields, and proper naming without writing code. This reduces errors and speeds up testing.

Using Make (formerly Integromat) for workflow orchestration

Make will be our workflow engine. We will use it to watch the sheet for new or updated rows, call JSONaut to produce payloads, send those payloads to Vapi, call the telephony provider to place calls, and update results back into the sheet. Make provides scheduling, error handling, and connector authentication in a visual canvas.

Text-to-speech and telephony options including common providers

For TTS and telephony we can use Vapi’s built-in TTS integrations or external providers such as commonly available telephony platforms and cloud TTS engines. The main decision is whether to let Vapi synthesize and route audio, or to generate audio separately and have a telephony provider play it. We will keep options open: use a natural-sounding voice for outreach that matches our brand and region.

Other optional tools: Zapier alternatives, databases, and logging

We may optionally swap Make for Zapier or use a database like Airtable or Firebase if we need more scalable storage. For logging and call analytics, we can add a simple logging table in Sheets or integrate an external logging service. The architecture remains the same: source → transform → agent → telephony → log.

Accounts, API Keys, and Permissions Setup

We will set up each service account and collect keys so Make and JSONaut can authenticate and call Vapi.

Creating and verifying a Vapi account and obtaining API credentials

We will sign up for a Vapi account and verify email and phone if required. In our Vapi console we will generate API credentials — typically an API key or token — that we will store securely. These credentials will allow Make to call Vapi’s agent endpoints and perform agent tests during orchestration.

Setting up a Google account and creating the Google Sheet access

We will log into our Google account and create a Google Sheet for leads. We will enable the Google Sheets API access through Make connectors by granting the scenario permission to read and write the sheet. If we use a service account, we will share the sheet with that service email to grant access.

Registering for JSONaut and generating required tokens

We will sign up for JSONaut and create an API token if required by their service. We will use that token in Make to call JSONaut endpoints to transform rows into the correct JSON format. We will test a sample transformation to confirm our token works.

Creating a Make account and granting API permissions

We will create and sign in to Make, then add Google Sheets, JSONaut, Vapi, and telephony modules to our scenario and authenticate each connector using the tokens and account credentials we collected. Make stores module credentials securely and allows us to reuse them across scenarios.

Configuring telephony provider credentials and webhooks if applicable

We will set up the telephony provider account and generate any required API keys or SIP credentials. If the telephony provider requires webhooks for call status callbacks, we will create endpoints in Make to receive those callbacks and map them back to sheet rows so we can log outcomes.

Security best practices for storing and rotating keys

We will store all credentials in Make’s encrypted connectors or a secrets manager, use least-privilege keys, and rotate tokens regularly. We will avoid hardcoding keys into sheets or public files and enforce multi-factor authentication on all accounts. We will also keep an audit of who has access to each service.

Preparing Your Lead Data in Google Sheets

We will design a sheet that contains both the lead contact details and fields we need for personalization and state tracking.

Designing columns for contact details, property data, and call status

We will create columns for core fields: Lead ID, Owner Name, Phone Number, Property Address, City, Estimated Value, Last Contacted, Call Status, Next Steps, and Notes. These fields let us personalize the script and track when a lead was last contacted and what the agent concluded.

Formatting tips for phone numbers and international dialing

We will store phone numbers in E.164 format where possible (+ country code followed by number) to avoid dial failures across providers. If we cannot store E.164, we will add a Dial Prefix column to allow Make to prepend an international code or local area code dynamically.

Adding personalization fields such as owner name and property attributes

We will include personalization columns like Owner First Name, Property Type, Bedrooms, Year Built, and Estimated Equity. The more relevant tokens we have, the better the agent can craft a conversational and contextual pitch that improves engagement.

Using validation rules and dropdowns to reduce data errors

We will use data validation to enforce dropdowns for Call Status (e.g., New, Called, Voicemail, Interested, Do Not Call) and date validation for Last Contacted. Validation reduces input errors and makes downstream automation more reliable.

Sample sheet template layout to copy and start with immediately

We will create a top row with headers: LeadID, OwnerName, PhoneE164, Address, City, State, Zip, PropertyType, EstValue, LastContacted, CallStatus, NextSteps, Notes. This row acts as a template we can copy for batches of leads and will map directly when configuring JSONaut.

Configuring JSONaut to Format Requests

We will set up JSONaut templates that take a sheet row and produce the exact JSON structure Vapi expects for agent input.

Purpose of JSONaut in transforming spreadsheet rows to JSON

We use JSONaut to ensure the data shape is correct and to avoid brittle concatenation in Make. JSONaut templates can map, rename, and compute fields, and they safeguard against undefined values that might break the Vapi agent payload.

Creating and testing a JSONaut template for Vapi agent input

We will create a JSONaut template that outputs an object with fields like contact: { name, phone }, property: { address, est_value }, and metadata: { lead_id, call_id }. We will test the template using a sample row to preview the JSON and adjust mappings until the structure aligns with Vapi’s expected schema.

Mapping Google Sheet columns to JSON payload fields

We will explicitly map each sheet column to a payload key, for example OwnerName → contact.name, PhoneE164 → contact.phone, and EstValue → property.est_value. We will include conditional logic to omit or default fields when the sheet is blank.

Handling optional fields and defaults to avoid empty-value errors

We will set defaults in JSONaut for optional fields (e.g., default est_value to “unknown” if missing) and remove fields that are empty so Vapi receives a clean payload. This prevents runtime errors and ensures the agent’s templating logic has consistent inputs.

Previewing payloads before sending to Vapi to validate structure

We will use JSONaut’s preview functionality to inspect outgoing JSON for several rows. We will check for correct data types, no stray commas, and presence of required fields. We will only push to Vapi after payloads validate successfully.

Building the Make Scenario to Orchestrate the Flow

We will construct the Make scenario that orchestrates each step from sheet change to placing a call and logging results.

Designing the Make scenario steps from watch spreadsheet to trigger

We will build a scenario that starts with a Google Sheets “Watch Rows” trigger for new or updated leads. Next steps will include filtering by CallStatus = New, transforming the row with JSONaut, sending the payload to Vapi, and finally invoking the telephony module or Vapi’s outbound call API.

Authenticating connectors for Google Sheets, JSONaut, Vapi and telephony

We will authenticate each Make module using our saved API keys and OAuth flows. Make will store these credentials securely, and we will select the connected accounts when adding modules to the scenario.

Constructing the workflow to assemble payloads and send to Vapi

We will connect the JSONaut module output to a HTTP or Vapi module that calls Vapi’s agent endpoint. The request will include our Vapi API key and the JSONaut body as the agent input. We will also set call metadata such as call_id and callback URLs if the telephony provider expects them.

Handling responses and logging call outcomes back to Google Sheets

We will parse the response from Vapi and the telephony provider and update the sheet with CallStatus (e.g., Called, Voicemail, Connected), LastContacted timestamp, and Notes containing any short transcript or disposition. If the call results in a lead request, we will set NextSteps to schedule follow-up or assign to a human agent.

Scheduling, rate limiting, and concurrency controls within Make

We will configure Make to limit concurrency and add delays or throttles to comply with telephony limits and to avoid mass calling at once. We will schedule the scenario to run during allowed calling hours and add conditional checks to skip numbers marked Do Not Call.

Creating and Configuring the Vapi AI Agent

We will set up the agent persona, prompts, and runtime behavior so it behaves consistently on calls.

Choosing agent persona, tone, and conversational style for cold calls

We will pick a persona that sounds professional, warm, and concise — a helpful local real estate advisor rather than a hard-sell bot. Our tone will be friendly and respectful, aiming to get permission to talk and qualify needs rather than push an immediate sale.

Defining system prompts and seed dialogues for consistent behavior

We will write system-level prompts that instruct the agent about goals, call length, privacy statements, and escalation rules. We will also provide seed dialogues for common scenarios: ideal outcome (schedule appointment), voicemail, and common objections like “not interested” or “already listed.”

Uploading or referencing personalization data for tailored scripts

We will ensure the agent receives personalization tokens (owner name, address, est value) from JSONaut and use those in prompts. We can upload small datasets or reference them in Vapi to improve personalization and keep the dialogue relevant to the prospect’s property.

Configuring call turn lengths, silence thresholds, and fallback behaviors

We will set limits on speech turn length so the agent speaks in natural chunks, configure silence detection to prompt the user if no response is heard, and set fallback behaviors to default to a concise voicemail message or offer to send a text when the conversation fails.

Testing the agent through the Vapi console before connecting to telephony

We will test the agent inside Vapi’s console with sample payloads to confirm conversational flow, voice rendering, and that personalization tokens render correctly. This reduces errors when we live-test via telephony.

Designing Conversation Flow and Prompts

We will craft a flow that opens the call, qualifies, pitches value, handles objections, and closes with a clear next step.

Structuring an opening script to establish relevance and permission to speak

We will open with a short introduction, mention a relevant data point (e.g., property address or recent market activity), and ask permission to speak: “Hi [Name], we’re calling about your property at [Address]. Is now a good time to talk?” This establishes relevance and respects the prospect’s time.

Creating smooth transitions between qualify, pitch, and close segments

We will design transition lines that move naturally: after permission we ask one or two qualifying questions, present a concise value statement tailored to the property, and then propose a clear next step such as scheduling a quick market review or sending more info via text or email.

Including objection-handling snippets and conditional branches

We will prepare short rebuttals for common objections like “not interested”, “already have an agent”, or “call me later.” Each snippet will be prefaced by a clarifying question and include a gentle pivot: e.g., “I understand — can I just ask if you’d be open to a no-obligation market snapshot for your records?”

Using personalization tokens to reference property and lead details

We will insert personalization tokens into prompts so the agent can say the owner’s name and reference the property value or attribute. Personalized language improves credibility and response rates, and we will ensure we supply those tokens from the sheet reliably.

Creating short fallback prompts for when the agent is uncertain

We will create concise fallback prompts for out-of-scope answers: “I’m sorry, I didn’t catch that. Can you tell me if you’re considering selling now, in the next six months, or not at all?” If the agent remains uncertain after two tries, it will default to offering to text information or flag the lead for human follow-up.

Text-to-Speech, Voice Settings, and Prosody

We will choose a voice and tune prosody so the agent sounds natural, clear, and engaging.

Selecting a natural-sounding voice appropriate for real estate outreach

We will choose a voice that matches our brand — warm, clear, and regionally neutral. We will prefer voices that use natural intonation and are proven in customer-facing use cases to avoid sounding robotic.

Adjusting speaking rate, pitch, and emphasis for clarity and warmth

We will slightly slow the speaking rate for clarity, use a mid-range pitch for approachability, and add emphasis to key phrases like the prospect’s name and the proposed next step. Small prosody tweaks make the difference between a confusing bot and a human-like listener.

Inserting SSML or voice markup where supported for better cadence

Where supported, we will use SSML tags to insert short pauses, emphasize tokens, and control sentence breaks. SSML helps the TTS engine produce more natural cadences and improves comprehension.

Balancing verbosity with succinctness to keep recipients engaged

We will avoid long monologues and keep each speaking segment under 15 seconds, then pause for a response. Short, conversational turns keep recipients engaged and reduce the chance of hang-ups.

Testing voice samples and swapping voices without changing logic

We will test different voice samples using the Vapi console, compare how personalization tokens sound, and switch voices if needed. Changing voice should not require changes to the conversation logic or the Make scenario.

Conclusion

We will summarize our build, encourage iteration, and touch on ethics and next steps.

Recap of what was built and the immediate next steps

We built an automated cold calling pipeline: a Google Sheet of leads, JSONaut templates to format payloads, a Make scenario to orchestrate flow, and a Vapi agent configured with persona, prompts, and TTS. Immediate next steps are to test on a small sample, review call logs, and refine prompts and call scheduling.

Encouragement to iterate on scripts and track measurable improvements

We will iterate on scripts based on call outcomes and track metrics like answer rate, conversion to appointment, and hang-up rate. Small prompt edits and personalization improvements often yield measurable increases in positive engagements.

Pointers to resources, templates, and where to seek help

We will rely on the Vapi console for agent testing, JSONaut previews to validate payloads, and Make’s scenario logs for debugging. If we run into issues, we will inspect API responses and adjust mappings or timeouts accordingly, and collaborate with teammates to refine scripts.

Final notes on responsible deployment and continuous improvement

We will deploy responsibly: respect Do Not Call lists and consent rules, keep calling within allowed hours, and provide clear opt-out options. Continuous improvement through A/B testing of scripts, voice styles, and personalized tokens will help us scale efficiently while maintaining a respectful, human-friendly outreach program.

If you want to implement Chat and Voice Agents into your business to reduce missed calls, book more appointments, save time, and make more revenue, book a discovery call here: https://brand.eliteaienterprises.com/widget/bookings/elite-ai-30-min-demo-call

December 4, 2025

Social Media Auto Publish Powered By : XYZScripts.com