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