How can we integrate Bolna AI With Google Sheets?

You know that feeling when you have a list of 50 people to call for reminders, confirmations, or surveys, and you're sitting there thinking "there has to be a better way than dialing each number manually"? Well, I just discovered something that's going to completely change how you think about phone outreach, and I had to share it with you right away.

Picture this: You have a spreadsheet with phone numbers. You hit a button. AI agents start making those calls automatically. The conversations happen naturally. Results get written back to your spreadsheet. All without you lifting a finger. Sounds too good to be true? That's exactly what Bolna + Google Sheets makes possible, and honestly, it's brilliant.

The Problem Everyone Faces (But Nobody Talks About)

Whether you're running a small business, managing events, or handling customer support, phone calls are still the most effective way to reach people. But they're also the most time-consuming. Manual dialing, repeating the same script, logging results—it's exhausting and kills productivity.

Email? Often ignored. SMS? Great, but limited. Phone calls? Personal, direct, and impossible to ignore. But who has time to make 50 calls a day?

That's where the magic of Bolna's AI calling platform combined with the simplicity of Google Sheets comes in. You get the power of AI-driven voice calls without writing a single line of backend code.

What Makes Bolna + Google Sheets Special?

Here's what got me genuinely excited about this integration:

• No Infrastructure Required
  You don't need servers, databases, or complex DevOps. Just a Google Sheet and a Bolna account. That's it. Set it up once, and you're done.

• Real-Time Updates
  As calls happen, your spreadsheet updates automatically. You can see who's been called, who answered, and what was discussed—all in one place.

• AI That Actually Sounds Human
  Bolna's AI agents don't sound like robots. They handle conversations naturally, respond to questions, and even adapt to different situations. It's not just playing a recording—it's having real conversations.

How It Actually Works (The Simple Version)

Think of it like this: your Google Sheet becomes a command center. Each row is a person to call. Mark a row as "pending," and Bolna's AI takes over. It makes the call, has the conversation, and writes back the result. You just check the sheet to see what happened.

The best part? You can test it with your own number first. Call yourself, see how the AI sounds, and once you're comfortable, scale it to hundreds of calls.

Alright, let's build this thing from scratch. Grab a coffee, and let's do this together. I'll walk you through every single step.

Step 1: Set Up Your Bolna Account (5 minutes)

1.1 Create Your Account

• Go to platform.bolna.ai
• Sign up with your email
• You'll get $5 in free credits automatically—enough for 50-100 test calls

1.2 Verify Your Phone Number
This is crucial. Bolna requires verified numbers to prevent spam.

• Click on Settings in the left sidebar
• Navigate to Verified Phone Numbers
• Click Add Number
• Enter your phone number in international format (e.g., [phone] or [phone])
• You'll receive an OTP—enter it
• Your number is now verified and ready to receive test calls

1.3 Generate Your API Key
This key is how your Google Sheet will talk to Bolna.

• Go to Settings → API Keys
• Click Create New API Key
• Give it a name like "Google Sheets Integration"
• Copy the key and save it somewhere safe—you won't see it again
• It looks something like: bolna_live_abc123xyz456...

Step 2: Create Your AI Agent (3 minutes)

2.1 Navigate to Agents

• Click Agents in the left menu
• Click Create New Agent

2.2 Choose a Template
Bolna gives you pre-built templates. Pick one that matches your use case:

• Appointment Reminder - For reminding customers about bookings
• Survey Agent - For collecting feedback
• Lead Qualification - For sales outreach
• General Support - For customer service calls

For this tutorial, let's pick Appointment Reminder.

2.3 Customize Your Agent (Optional)

• You can edit the first message the agent says
• Example: "Hi, this is an automated reminder from [Your Company]. I'm calling to confirm your appointment scheduled for tomorrow at 3 PM. Can you confirm if you'll be able to make it?"
• Keep it short and natural

2.4 Save and Copy Agent ID

• Click Save
• You'll see an Agent ID (looks like agent_abc123xyz)
• Copy this—you'll need it in your script

Step 3: Set Up Your Google Sheet (5 minutes)

3.1 Create a New Google Sheet

• Go to sheets.google.com
• Create a new spreadsheet
• Name it something like "Bolna Call Automation"

3.2 Set Up Your Columns
Create these exact column headers in Row 1:

A	B	C	D
Phone Number	Status	Call ID	Result

3.3 Add Your Test Data
Fill in a few rows like this:

Phone Number	Status	Call ID	Result
[phone]	pending
[phone]	pending

Important formatting tip:

• Make sure phone numbers are in E.164 format (+CountryCodePhoneNumber)
• Format Column A as Plain Text (Format → Number → Plain Text) so Google Sheets doesn't remove the "+"

Step 4: Write the Google Apps Script (10 minutes)

This is where the magic happens. Don't worry—I'll walk you through every line.

4.1 Open Apps Script Editor

• In your Google Sheet, click Extensions → Apps Script
• You'll see a code editor with some default code
• Delete everything in there

4.2 Paste This Complete Script

const BOLNA_API_KEY = "YOUR_API_KEY_HERE";  // Paste your Bolna API key
const AGENT_ID = "YOUR_AGENT_ID_HERE";      // Paste your agent ID

function triggerCalls() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const lastRow = sheet.getLastRow();

  // Skip if only header row exists
  if (lastRow < 2) {
    Logger.log("No data rows found");
    return;
  }

  // Get all data rows (starting from row 2)
  const rows = sheet.getRange(2, 1, lastRow - 1, 4).getValues();

  rows.forEach((row, index) => {
    const phoneNumber = row[0];
    const status = row[1];
    const rowNumber = index + 2; // +2 because arrays start at 0 and we skip header

    // Only process rows marked as "pending"
    if (phoneNumber && status === "pending") {
      try {
        Logger.log(`Processing row ${rowNumber}: ${phoneNumber}`);

        // Make the API call to Bolna
        const callId = makeBolnaCall(phoneNumber);

        // Update the sheet with new status and call ID
        sheet.getRange(rowNumber, 2).setValue("initiated"); // Status column
        sheet.getRange(rowNumber, 3).setValue(callId);      // Call ID column

        Logger.log(`Call initiated successfully: ${callId}`);

      } catch (error) {
        Logger.log(`Error for row ${rowNumber}: ${error.message}`);
        sheet.getRange(rowNumber, 2).setValue("error");
        sheet.getRange(rowNumber, 4).setValue(error.message);
      }
    }
  });
}

function makeBolnaCall(phoneNumber) {
  const url = "https://api.bolna.dev/call";

  const payload = {
    agent_id: AGENT_ID,
    recipient_phone_number: phoneNumber,
    // You can add more options here:
    // user_data: { customer_name: "John Doe" }
  };

  const options = {
    method: "post",
    contentType: "application/json",
    headers: {
      "Authorization": `Bearer ${BOLNA_API_KEY}`
    },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  };

  const response = UrlFetchApp.fetch(url, options);
  const statusCode = response.getResponseCode();
  const responseBody = response.getContentText();

  Logger.log(`API Response Code: ${statusCode}`);
  Logger.log(`API Response Body: ${responseBody}`);

  // Check if the call was successful
  if (statusCode !== 200 && statusCode !== 201) {
    throw new Error(`Bolna API error (${statusCode}): ${responseBody}`);
  }

  const data = JSON.parse(responseBody);

  // Return the call ID from the response
  return data.call_id || data.id;
}

function updateCallStatuses() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const lastRow = sheet.getLastRow();

  if (lastRow < 2) return;

  const rows = sheet.getRange(2, 1, lastRow - 1, 4).getValues();

  rows.forEach((row, index) => {
    const callId = row[2];      // Call ID column
    const status = row[1];      // Status column
    const rowNumber = index + 2;

    // Only check calls that are not yet completed
    if (callId && status !== "completed" && status !== "failed" && status !== "error") {
      try {
        const callData = getCallStatus(callId);

        // Update status
        sheet.getRange(rowNumber, 2).setValue(callData.status);

        // If call is completed, add the result/summary
        if (callData.status === "completed") {
          const result = callData.summary || callData.transcript_summary || "Call completed successfully";
          sheet.getRange(rowNumber, 4).setValue(result);
        }

        // If call failed, log the reason
        if (callData.status === "failed") {
          const reason = callData.failure_reason || "Call failed";
          sheet.getRange(rowNumber, 4).setValue(reason);
        }

      } catch (error) {
        Logger.log(`Error checking status for row ${rowNumber}: ${error.message}`);
      }
    }
  });
}

function getCallStatus(callId) {
  const url = `https://api.bolna.dev/call/${callId}`;

  const options = {
    method: "get",
    headers: {
      "Authorization": `Bearer ${BOLNA_API_KEY}`
    },
    muteHttpExceptions: true
  };

  const response = UrlFetchApp.fetch(url, options);
  const statusCode = response.getResponseCode();
  const responseBody = response.getContentText();

  if (statusCode !== 200) {
    throw new Error(`Failed to get call status (${statusCode}): ${responseBody}`);
  }

  return JSON.parse(responseBody);
}

function resetAllToPending() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const lastRow = sheet.getLastRow();

  if (lastRow < 2) return;

  // Clear status, call ID, and result columns
  sheet.getRange(2, 2, lastRow - 1, 3).clearContent();

  // Set all to pending
  for (let i = 2; i <= lastRow; i++) {
    sheet.getRange(i, 2).setValue("pending");
  }

  Logger.log("All rows reset to pending");
}

4.3 Update Your Configuration
At the top of the script, replace:

• YOUR_API_KEY_HERE with your actual Bolna API key
• YOUR_AGENT_ID_HERE with your actual agent ID

4.4 Save the Script

• Click the Save icon (💾)
• Give your project a name like "Bolna Integration"

Step 5: Test Your First Call (5 minutes)

5.1 Run the Script Manually

• In the Apps Script editor, select triggerCalls from the function dropdown at the top
• Click Run (▶️)

5.2 Authorize the Script
The first time you run it, Google will ask for permissions:

• Click Review Permissions
• Choose your Google account
• Click Advanced → Go to Your Project Name
• Click Allow

(Don't worry—this is safe. Google just shows this warning for custom scripts)

5.3 Check the Logs

• Click Execution Log at the bottom
• You should see: Call initiated successfully: call_xyz123

5.4 Your Phone Rings!
Within 10-20 seconds, your verified phone number should ring. Answer it and have a conversation with the AI agent.

5.5 Watch Your Sheet Update
Go back to your Google Sheet. You should see:

• Status changed to "initiated"
• Call ID appeared in Column C

Step 6: Set Up Automatic Status Updates (5 minutes)

Right now, you have to manually check call status. Let's automate that.

6.1 Create a Trigger

• In Apps Script, click the clock icon (⏰) on the left sidebar (Triggers)
• Click Add Trigger

6.2 Configure the Trigger
Set these values:

• Choose which function to run: updateCallStatuses
• Choose which deployment: Head
• Select event source: Time-driven
• Select type of time trigger: Minutes timer
• Select minute interval: Every 1 minute

6.3 Save the Trigger

• Click Save
• Authorize again if prompted

Now, every minute, your sheet will automatically check if calls are completed and update the results!

Step 7: See the Results

After your call ends (usually 1-2 minutes), refresh your Google Sheet. You should see:

Phone Number	Status	Call ID	Result
[phone]	completed	call_xyz123	Customer confirmed appointment for tomorrow at 3 PM

The Result column now contains a summary of what happened during the call!

What I Love About This Approach

• It's Transparent
  Everything happens in a spreadsheet you control. No black boxes. No hidden processes. Just rows of data you can see and manage.

• It's Flexible
  Want to add more fields? Just add columns. Need to change the script? Tweak it. It adapts to your workflow, not the other way around.

• It's Scalable
  
  Start with 5 calls. Scale to 500. The process is the same. You're not locked into any plan or paying per seat.

• It's Accessible
  Even non-developers can set this up. If you can create a Google Sheet (and you probably can), you can build this.

The Technical Bit (For Those Who Care)

Under the hood, you're using:

• Bolna's REST API to trigger calls and fetch status
• Google Apps Script (basically JavaScript) to connect your sheet to Bolna
• Triggers to automate status updates every minute

The script does three things:

1. Reads rows marked "pending"
2. Calls Bolna's API to initiate calls
3. Polls call status and writes results back

It's event-driven, lightweight, and doesn't require any server hosting.

Why This Matters (The Big Picture)

AI phone calls aren't science fiction anymore. They're practical, affordable, and accessible to anyone. What used to require call centers and massive budgets now fits in a Google Sheet.

This isn't about replacing humans—it's about letting AI handle the repetitive, predictable parts so humans can focus on what matters: complex problems, empathy, and decision-making.

Whether you're a solo entrepreneur, a growing startup, or a team inside a larger company, this integration gives you superpowers. You can reach more people, faster, without sacrificing quality.

Final Thoughts

The best tools are the ones that just work. No unnecessary complexity. No vendor lock-in. No steep learning curve. Bolna + Google Sheets is exactly that—simple, powerful, and surprisingly fun to build.

If you've been looking for a way to automate phone calls without hiring developers or buying expensive software, this is your answer. Give it a shot. Test it with your own number. See what happens when AI handles your outreach.

Trust me, once you see your first automated call complete and the result appear in your spreadsheet, you'll wonder how you ever did it manually.

Now go build something cool. And when it works, share it. The community needs more builders who aren't afraid to experiment.

---

Ready to start? Head to platform.bolna.ai and create your account. You're literally 20 minutes away from automated AI phone calls.