AI-Powered Cold Calling Automation with Vapi.ai, GPT-4o & Google Sheets
πAI-Powered Cold Calling Automation with Vapi.ai, GPT-4o & Google Sheets
Overview
Transform your lead list into an AI-powered calling machine. This workflow automates your entire cold calling process using Vapi's conversational AI to initiate calls, qualify leads, capture detailed insights, and manage intelligent follow-ups - achieving 10x more calls than manual efforts while maintaining personalized, professional conversations.
Built for sales teams, recruiters, and customer success professionals who need to scale outreach without sacrificing quality or adding headcount.
π― Use Cases
Sales & Business Development
- Lead Qualification: Auto-dial new leads to assess interest and budget
- Demo Scheduling: Book meetings with qualified prospects automatically
- Re-engagement: Win back cold leads with personalized outreach
- Product Launches: Announce new features to your entire customer base
Recruitment & HR
- Candidate Screening: Conduct first-round interviews at scale
- Interview Scheduling: Coordinate availability without back-and-forth
- Reference Checks: Automate reference verification calls
- Offer Follow-ups: Ensure candidates received and understood offers
Customer Success
- Onboarding Calls: Welcome new customers with consistent messaging
- Renewal Reminders: Proactively reach out before contract expiration
- Upsell Campaigns: Identify expansion opportunities through conversations
- NPS Surveys: Gather voice feedback for authentic insights
Market Research
- Customer Interviews: Collect qualitative feedback at scale
- Product Validation: Test new concepts with target audiences
- Competitive Intelligence: Understand why customers chose competitors
- Industry Surveys: Gather market trends through conversational data
βοΈ How it Works
The workflow operates through two parallel processes:
Process 1: Call Initiation (Manual/On-Demand)
- Trigger: Manual start or scheduled batch processing
- Lead Retrieval: Fetches leads marked "Pending" or "Retry Scheduled" from Google Sheets
- Validation: Checks retry count (max 5 attempts) and routes accordingly
- API Call: Sends request to Vapi with lead details and AI assistant configuration
- Status Update: Marks lead as "Call Initiated" with unique call ID
- Batch Processing: Loops through all eligible leads with controlled pacing
Process 2: Result Collection (Every 10 Minutes)
- Schedule Trigger: Automatic execution every 10 minutes
- Active Call Check: Identifies all "Call Initiated" records
- Result Fetching: Retrieves call outcomes from Vapi API
- Data Processing: Extracts recordings, transcripts, summaries, and interest scores
- Sheet Update: Writes complete results or schedules retry for missed calls
- Team Notification: Sends Slack alerts on batch completion
π Setup Instructions
Prerequisites
- n8n Instance: Version 1.0.0+ (self-hosted or cloud)
- Google Account: With Sheets API enabled
- Vapi Account: Active subscription with API access
- Slack Workspace: Optional, for notifications
Step 1: Prepare Your Lead Database
Create a Google Sheet with these exact columns (case-sensitive):
Customer_id | Name | Phone Number | Email | Status | Recording URL | Transcript | Summary | Interest | Call Duration | Retry count | Last attempt | Call ID
Initial Setup:
Customer_id: Unique identifier (e.g., LEAD001)Name: Full name for personalizationPhone Number: International format (+14155551234)Email: For follow-up campaignsStatus: Set to "Pending"Retry count: Set to 0- Other fields: Leave empty (auto-populated)
Step 2: Configure Vapi AI Assistant
-
Create Your AI Voice Agent
- Log into vapi.ai
- Navigate to Assistants β Create New
- Design your conversation flow
- Configure voice settings (gender, accent, speed)
- Set up objection handling
- Save and copy the
Assistant ID
-
Set Up Phone Number
- Go to Phone Numbers β Purchase/Import
- Select local or toll-free number
- Configure caller ID settings
- Copy the
Phone Number ID
Step 3: Import & Configure Workflow
-
Import to n8n
- Download
Cold_calling_loop.json - In n8n: Import β From File
- Select the JSON file
- Download
-
Connect Credentials
- Google Sheets: OAuth2 authentication
- Vapi API: HTTP Header Auth
- Name:
Authorization - Value:
Bearer YOUR_API_KEY
- Name:
- Slack: OAuth2 (optional)
-
Update Configuration
- All Google Sheets nodes: Select your spreadsheet
- HTTP Request nodes: Update
assistantIdandphoneNumberId - Slack nodes: Choose notification channels
Step 4: Test & Deploy
- Add test lead with your phone number
- Execute workflow manually
- Answer call and complete conversation
- Verify results in Google Sheet
- Activate workflow for production
π Workflow Logic Explained
Status Flow Diagram
[New Lead: Pending] β [Call Initiated] β [Completed/Failed]
β
[Retry Scheduled] β (if failed & retry < 5)
Key Decision Points
-
Retry Limit Check (If1 Node)
- Condition:
Retry count β€ 5 - True: Proceed with call
- False: Mark as "Max Retries Reached"
- Condition:
-
Call Completion Check (If2 Node)
- Validates: Recording exists, transcript available, analysis complete
- Success: Update with full results
- Failure: Schedule retry with incremented counter
-
Status Routing (If4 Node)
- "Pending": Direct to call queue
- "Retry Scheduled": Add wait period before calling
π Node Reference Guide
Core Processing Nodes
| Node | Type | Purpose | Configuration | |------|------|---------|---------------| | Get Leads from Sheet1 | Google Sheets | Fetches eligible leads | Filter: Status = "Pending" OR "Retry Scheduled" | | HTTP Request | HTTP | Initiates Vapi call | POST to api.vapi.ai/call with assistant config | | Loop Over Items | Split In Batches | Processes leads individually | Batch size: 1, ensures sequential processing | | Get Call Data | HTTP | Retrieves call results | GET from api.vapi.ai/call?id={callId} | | Edit Fields2 | Set | Formats result data | Maps Vapi response to sheet columns |
Status Management Nodes
| Node | Updates | Trigger | |------|---------|---------| | Update Status - Calling1 | "Call Initiated" | After successful API call | | Update Status - Calling | "Done" + results | When call completed successfully | | Update Status - for Missed call | "Retry Scheduled" | When call failed/no answer | | Update Status - Calling3 | "Retry Done" | After retry limit reached |
Control Flow Nodes
| Node | Function | Logic | |------|----------|-------| | If1 | Retry validation | Checks retry count β€ 5 | | If2 | Result validation | Verifies call completion | | Wait | Retry delay | Pauses before retry attempt | | Merge | Path combination | Unifies success/retry flows |
π οΈ Customization Guide
1. Modify Retry Strategy
// Add to Code node for progressive delays
const retryCount = $json["Retry count"];
const delays = {
1: 30, // 30 minutes
2: 120, // 2 hours
3: 1440, // Next day
4: 2880, // 2 days
5: 10080 // 1 week
};
return { waitMinutes: delays[retryCount] || 60 };
2. Add Business Hours Check
// Add before HTTP Request node
const now = new Date();
const hour = now.getHours();
const day = now.getDay();
const isWeekday = day >= 1 && day <= 5;
const isBusinessHours = hour >= 9 && hour <= 17;
if (!isWeekday || !isBusinessHours) {
throw new Error('Outside calling hours');
}
3. Enhance Lead Context
{
"assistantId": "your-assistant-id",
"phoneNumberId": "your-phone-id",
"customer": {
"number": "+{{ $json['Phone Number'] }}",
"name": "{{ $json.Name }}",
"customData": {
"company": "{{ $json.Company }}",
"lastPurchase": "{{ $json['Last Purchase Date'] }}",
"accountValue": "{{ $json['Account Value'] }}",
"preferredProduct": "{{ $json['Product Interest'] }}"
}
}
}
π‘ Sticky Notes Configuration
Note 1: Status Progression
Location: Near Google Sheets nodes
π LEAD STATUS FLOW:
Pending β Call Initiated β Done/Retry Scheduled
Retry Scheduled β Call Initiated β Done/Failed
β οΈ Max retries: 5 attempts
β Failed = No answer after 5 tries
β
Done = Call completed with results
Note 2: Phone Format Requirements
Location: Near HTTP Request nodes
π± PHONE NUMBER FORMAT:
β
Correct: +14155551234
β Wrong: (415) 555-1234
β Wrong: 415-555-1234
Must include:
- Plus sign (+)
- Country code
- No spaces or symbols
Note 3: Vapi Setup Checklist
Location: At workflow start
π§ VAPI CONFIGURATION:
β‘ Assistant ID copied from Vapi
β‘ Phone Number ID from Vapi
β‘ API Key in credentials
β‘ Credits available
β‘ Assistant tested in playground
Note 4: Performance Guidelines
Location: Near Loop nodes
β‘ OPTIMIZATION TIPS:
β’ Batch size: 10-20 leads
β’ Call hours: 9 AM - 5 PM local
β’ Delay between calls: 5 seconds
β’ Monthly archive old records
β’ Monitor Vapi credit usage
Common Issues & Solutions
π΄ "Authentication Failed"
Cause: Expired or invalid credentials Fix:
- Re-authenticate Google Sheets OAuth
- Verify Vapi API key is active
- Check credential permissions
π΄ "Call Not Initiating"
Cause: Invalid phone format or Vapi configuration Fix:
- Ensure phone includes country code
- Verify Vapi account has credits
- Test assistant in Vapi playground
- Check assistant and phone IDs
π΄ "Missing Results"
Cause: Call still processing or webhook failure Fix:
- Wait 3-5 minutes for processing
- Check Vapi dashboard directly
- Verify Get Call Data node query
- Review If2 conditions
π΄ "Infinite Loop"
Cause: Status not updating correctly Fix:
- Check retry count increment logic
- Verify status update mappings
- Clear test data and restart
π΄ "No Slack Notifications"
Cause: Bot permissions or channel access Fix:
- Invite bot to channel
- Verify OAuth scopes
- Test Slack node individually
π Required Files & Resources
| File | Description | Location |
|------|-------------|----------|
| Cold_calling_loop.json | Complete workflow configuration | Main workflow file |
| lead_template.xlsx | Google Sheets template with headers | Sample data file |
π·οΈ Tags & Categories
Primary Category
Sales & Marketing Automation
Workflow Tags
cold-calling vapi-ai voice-automation lead-generation ai-sales google-sheets outbound-calling sales-automation conversational-ai crm-automation
Use Case Tags
b2b-sales recruitment customer-success market-research appointment-setting lead-qualification follow-up-automation
Integration Tags
vapi google-sheets slack voice-ai telephony
π Future Enhancements
Planned Features
- CRM Integration: Direct sync with Salesforce/HubSpot
- Multi-language: Support for 10+ languages
- SMS Follow-up: Automated text after calls
- Analytics Dashboard: Real-time performance metrics
- Sentiment Analysis: Emotional intelligence scoring
Community Roadmap
- Webhook support for real-time updates
- Custom voice training options
- A/B testing for scripts
- Predictive best time to call
- Integration with calendar systems
π Support & Resources
Support email : amitswba@gmail.com
AI-Powered Cold Calling Automation with VAPI.ai, GPT-4o, and Google Sheets
This n8n workflow automates the process of cold calling by leveraging AI to generate personalized scripts and manage call outcomes, integrating with VAPI.ai for voice AI, GPT-4o for content generation, and Google Sheets for data management. It streamlines lead outreach, ensures consistent messaging, and provides a structured way to track and react to call results.
What it does
This workflow simplifies and automates several key aspects of an AI-powered cold calling process:
- Triggers Manually or on Schedule: The workflow can be initiated manually for testing or on a predefined schedule (e.g., daily, weekly) to process new leads.
- Fetches Leads from Google Sheets: It reads a list of leads from a specified Google Sheet, providing the contact information and any other relevant data for the cold call.
- Prepares Data for AI Call: Transforms and sets the necessary data fields (like
customer_name,customer_email,customer_phone,company_name,product_name) to be used in the AI-powered cold call. - Initiates AI Cold Call via VAPI.ai: For each lead, it makes an HTTP request to the VAPI.ai API to initiate an AI-driven cold call. This call uses a pre-defined assistant and passes the personalized lead data.
- Handles VAPI.ai Callbacks: It's designed to receive callbacks from VAPI.ai, indicating the status and outcome of the call.
- Processes Call Outcomes: Based on the VAPI.ai callback, it checks if the call was successful (e.g.,
call_statusis "completed"). - Updates Google Sheet with Call Outcome: If the call is completed, it updates the corresponding row in the Google Sheet with the call's outcome, duration, and any other relevant data received from VAPI.ai.
- Notifies via Slack (Optional): If the call is completed, it can optionally send a notification to a Slack channel with details of the successful call.
- Pauses for Rate Limiting (Optional): Includes a
Waitnode to introduce a delay between calls, helping to manage API rate limits or simulate a more natural calling pace.
Prerequisites/Requirements
To use this workflow, you will need:
- n8n Instance: A running instance of n8n.
- Google Sheets Account: With a spreadsheet containing your lead data. You'll need to configure Google Sheets credentials in n8n.
- VAPI.ai Account & API Key: For making AI-powered voice calls. You'll need to configure an HTTP Request node with your VAPI.ai API key and endpoint.
- GPT-4o (or similar LLM) Integration (Implicit): While not directly shown as a separate node, the VAPI.ai assistant is expected to be configured with GPT-4o (or another LLM) for generating dynamic and personalized call scripts.
- Slack Account (Optional): If you wish to receive notifications about successful calls, you'll need a Slack account and credentials configured in n8n.
Setup/Usage
- Import the Workflow: Download the provided JSON and import it into your n8n instance.
- Configure Credentials:
- Google Sheets: Set up your Google Sheets OAuth2 credentials.
- VAPI.ai: The
HTTP Requestnode for VAPI.ai will require an API key, likely passed as a header (e.g.,Authorization: Bearer YOUR_VAPI_AI_API_KEY). - Slack (Optional): Set up your Slack API credentials.
- Configure Google Sheets Node (Node 18):
- Specify your Spreadsheet ID and Sheet Name where your lead data is stored.
- Ensure the sheet contains columns for
customer_name,customer_email,customer_phone,company_name,product_name, and a column to store thecall_statusandcall_outcome.
- Configure Edit Fields Node (Node 38):
- Map the incoming data from Google Sheets to the fields expected by VAPI.ai (e.g.,
customer_name,customer_email,customer_phone,company_name,product_name).
- Map the incoming data from Google Sheets to the fields expected by VAPI.ai (e.g.,
- Configure HTTP Request Node (Node 19):
- Update the URL to your VAPI.ai API endpoint for initiating a call (e.g.,
https://api.vapi.ai/call/phone). - Set the HTTP Method to
POST. - Ensure the Headers include your VAPI.ai API key (e.g.,
Authorization: Bearer {{ $env.VAPI_AI_API_KEY }}). - The Body should be a JSON object containing the
assistant_idand the lead data mapped from the previous node (e.g.,customer_name,customer_email,customer_phone,company_name,product_name).
- Update the URL to your VAPI.ai API endpoint for initiating a call (e.g.,
- Configure If Node (Node 20):
- Adjust the condition to check for the desired successful call status from VAPI.ai (e.g.,
{{ $json.call_status === 'completed' }}).
- Adjust the condition to check for the desired successful call status from VAPI.ai (e.g.,
- Configure Slack Node (Node 40 - Optional):
- Specify the Channel to post messages to.
- Customize the Text message to include relevant call details (e.g.,
Call for {{ $json.customer_name }} completed with status: {{ $json.call_status }}).
- Configure Wait Node (Node 514 - Optional):
- Adjust the Delay time to control the interval between calls, if needed.
- Activate the Workflow: Once configured, activate the workflow. You can then trigger it manually or let the
Schedule Triggerhandle it automatically.
Related Templates
Generate song lyrics and music from text prompts using OpenAI and Fal.ai Minimax
Spark your creativity instantly in any chatβturn a simple prompt like "heartbreak ballad" into original, full-length lyrics and a professional AI-generated music track, all without leaving your conversation. π What This Template Does This chat-triggered workflow harnesses AI to generate detailed, genre-matched song lyrics (at least 600 characters) from user messages, then queues them for music synthesis via Fal.ai's minimax-music model. It polls asynchronously until the track is ready, delivering lyrics and audio URL back in chat. Crafts original, structured lyrics with verses, choruses, and bridges using OpenAI Submits to Fal.ai for melody, instrumentation, and vocals aligned to the style Handles long-running generations with smart looping and status checks Returns complete song package (lyrics + audio link) for seamless sharing π§ Prerequisites n8n account (self-hosted or cloud with chat integration enabled) OpenAI account with API access for GPT models Fal.ai account for AI music generation π Required Credentials OpenAI API Setup Go to platform.openai.com β API keys (sidebar) Click "Create new secret key" β Name it (e.g., "n8n Songwriter") Copy the key and add to n8n as "OpenAI API" credential type Test by sending a simple chat completion request Fal.ai HTTP Header Auth Setup Sign up at fal.ai β Dashboard β API Keys Generate a new API key β Copy it In n8n, create "HTTP Header Auth" credential: Name="Fal.ai", Header Name="Authorization", Header Value="Key [Your API Key]" Test with a simple GET to their queue endpoint (e.g., /status) βοΈ Configuration Steps Import the workflow JSON into your n8n instance Assign OpenAI API credentials to the "OpenAI Chat Model" node Assign Fal.ai HTTP Header Auth to the "Generate Music Track", "Check Generation Status", and "Fetch Final Result" nodes Activate the workflowβchat trigger will appear in your n8n chat interface Test by messaging: "Create an upbeat pop song about road trips" π― Use Cases Content Creators: YouTubers generating custom jingles for videos on the fly, streamlining production from idea to audio export Educators: Music teachers using chat prompts to create era-specific folk tunes for classroom discussions, fostering interactive learning Gift Personalization: Friends crafting anniversary R&B tracks from shared memories via quick chats, delivering emotional audio surprises Artist Brainstorming: Songwriters prototyping hip-hop beats in real-time during sessions, accelerating collaboration and iteration β οΈ Troubleshooting Invalid JSON from AI Agent: Ensure the system prompt stresses valid JSON; test the agent standalone with a sample query Music Generation Fails (401/403): Verify Fal.ai API key has minimax-music access; check usage quotas in dashboard Status Polling Loops Indefinitely: Bump wait time to 45-60s for complex tracks; inspect fal.ai queue logs for bottlenecks Lyrics Under 600 Characters: Tweak agent prompt to enforce fuller structures like [V1][C][V2][B][C]; verify output length in executions
AI-powered code review with linting, red-marked corrections in Google Sheets & Slack
Advanced Code Review Automation (AI + Lint + Slack) Whoβs it for For software engineers, QA teams, and tech leads who want to automate intelligent code reviews with both AI-driven suggestions and rule-based linting β all managed in Google Sheets with instant Slack summaries. How it works This workflow performs a two-layer review system: Lint Check: Runs a lightweight static analysis to find common issues (e.g., use of var, console.log, unbalanced braces). AI Review: Sends valid code to Gemini AI, which provides human-like review feedback with severity classification (Critical, Major, Minor) and visual highlights (red/orange tags). Formatter: Combines lint and AI results, calculating an overall score (0β10). Aggregator: Summarizes results for quick comparison. Google Sheets Writer: Appends results to your review log. Slack Notification: Posts a concise summary (e.g., number of issues and average score) to your teamβs channel. How to set up Connect Google Sheets and Slack credentials in n8n. Replace placeholders (<YOURSPREADSHEETID>, <YOURSHEETGIDORNAME>, <YOURSLACKCHANNEL_ID>). Adjust the AI review prompt or lint rules as needed. Activate the workflow β reviews will start automatically whenever new code is added to the sheet. Requirements Google Sheets and Slack integrations enabled A configured AI node (Gemini, OpenAI, or compatible) Proper permissions to write to your target Google Sheet How to customize Add more linting rules (naming conventions, spacing, forbidden APIs) Extend the AI prompt for project-specific guidelines Customize the Slack message formatting Export analytics to a dashboard (e.g., Notion or Data Studio) Why itβs valuable This workflow brings realistic, team-oriented AI-assisted code review to n8n β combining the speed of automated linting with the nuance of human-style feedback. It saves time, improves code quality, and keeps your teamβs review history transparent and centralized.
Auto-reply & create Linear tickets from Gmail with GPT-5, gotoHuman & human review
This workflow automatically classifies every new email from your linked mailbox, drafts a personalized reply, and creates Linear tickets for bugs or feature requests. It uses a human-in-the-loop with gotoHuman and continuously improves itself by learning from approved examples. How it works The workflow triggers on every new email from your linked mailbox. Self-learning Email Classifier: an AI model categorizes the email into defined categories (e.g., Bug Report, Feature Request, Sales Opportunity, etc.). It fetches previously approved classification examples from gotoHuman to refine decisions. Self-learning Email Writer: the AI drafts a reply to the email. It learns over time by using previously approved replies from gotoHuman, with per-classification context to tailor tone and style (e.g., different style for sales vs. bug reports). Human Review in gotoHuman: review the classification and the drafted reply. Drafts can be edited or retried. Approved values are used to train the self-learning agents. Send approved Reply: the approved response is sent as a reply to the email thread. Create ticket: if the classification is Bug or Feature Request, a ticket is created by another AI agent in Linear. Human Review in gotoHuman: How to set up Most importantly, install the gotoHuman node before importing this template! (Just add the node to a blank canvas before importing) Set up credentials for gotoHuman, OpenAI, your email provider (e.g. Gmail), and Linear. In gotoHuman, select and create the pre-built review template "Support email agent" or import the ID: 6fzuCJlFYJtlu9mGYcVT. Select this template in the gotoHuman node. In the "gotoHuman: Fetch approved examples" http nodes you need to add your formId. It is the ID of the review template that you just created/imported in gotoHuman. Requirements gotoHuman (human supervision, memory for self-learning) OpenAI (classification, drafting) Gmail or your preferred email provider (for email trigger+replies) Linear (ticketing) How to customize Expand or refine the categories used by the classifier. Update the prompt to reflect your own taxonomy. Filter fetched training data from gotoHuman by reviewer so the writer adapts to their personalized tone and preferences. Add more context to the AI email writer (calendar events, FAQs, product docs) to improve reply quality.