How to Build a Review Automation Agent for Any Local Business

Ask any local business owner how they get Google reviews and you’ll hear some version of the same answer: “We ask when we remember to.” Maybe a technician mentions it at the end of a job. Maybe the front desk prompts a customer on a good day. Maybe there’s a sign somewhere that says “Find us on Google.”

That’s not a system. That’s hope.

Here’s what Google actually rewards: velocity and volume. A business collecting 15 new reviews a month will consistently outrank a competitor with a better average rating but stagnant review growth. Google interprets review velocity as a trust signal — an active, engaged business that real customers keep returning to. A static review count, even a high one, sends the opposite signal over time.

The gap between businesses that dominate local search and those that don’t is rarely about the quality of service. It’s almost always about whether they have a reliable, repeatable process for turning happy customers into published reviews. A review automation agent closes that gap permanently.

This is a practical guide to building one — the exact sequence, the tooling, the Claude setup, and the deployment steps. No SMS required, no expensive platforms, no ongoing subscription fees beyond what you’re already paying. Just Claude, Gmail, and a bit of automation glue.

What a Review Automation Agent Actually Is

A review automation agent is not a broadcast email tool. It’s not a “leave us a review!” text sent to your entire contact list. Done correctly, it’s a triggered sequence that fires at the right moment for the right customer — and personalizes the outreach based on what just happened.

The architecture has three parts:

1. A trigger — an event in your existing business software that fires when a transaction is complete. Job completion in a field service CRM. A closed appointment in a booking platform. A paid invoice in QuickBooks. Whatever system the business already uses to track completed work.

2. A Claude agent — receives the trigger data (customer name, service type, staff member, business info) and generates a personalized email for each touchpoint in the sequence. Not a template with names swapped in — actual varied, human-sounding copy that changes with each customer and each job.

3. Gmail API delivery — sends the emails from a real Gmail or Google Workspace address at scheduled intervals. Day 0, Day 3, Day 7. The emails look exactly like something a real person wrote and sent.

The customer receives what feels like a personal follow-up from a business that genuinely cares about their experience. That’s the reason conversion rates on well-built agents run 10–20%, versus the 2–4% you’d get from a generic blast.

Why Email-Only Works Fine

There’s a persistent belief in local marketing circles that SMS is mandatory for review requests because open rates are higher. Ignore it.

Yes, SMS open rates are higher in aggregate. But for review requests specifically, the channel matters less than the timing and personalization. A well-personalized email arriving at the right moment — within hours of a completed service — converts at rates that match or beat SMS benchmarks for this use case.

More practically: email is significantly easier to build, maintain, and customize. There are no carrier compliance headaches, no opt-in/opt-out regulatory requirements (CAN-SPAM compliance for transactional email is straightforward), no per-message costs, and no risk of a carrier flagging your messages as spam and silently dropping them.

Gmail and Google Workspace are tools virtually every small business already uses. The Gmail API is well-documented, the OAuth2 setup takes under 30 minutes, and Make.com, n8n, and most CRMs have native Gmail integrations built in. The infrastructure is already there.

Build email. Ship it. Iterate. The complexity that SMS adds is not worth the marginal gain.

The Exact 3-Email Sequence

This is the sequence I deploy for every review agent build. Three emails, three specific jobs, nothing more.

Email 1 — Day 0: The Thank You (sent within 2 hours of job completion)

The first email is not a review request. It’s a thank you. This is intentional.

Sending a review request within minutes of a completed job feels transactional and slightly aggressive. Leading with genuine appreciation — and mentioning the specific service and staff member — sets a warmer tone and significantly improves response rates on the emails that follow.

The Day 0 email should:

Thank the customer by first name
Reference the specific service completed
Mention the staff member if known
Be 3–4 sentences maximum
Include no review link (save that for Day 3)

Claude prompt for Day 0:

You are writing a post-service thank you email for [BUSINESS NAME], a local [BUSINESS TYPE].

Customer first name: [FIRST NAME]
Service completed: [SERVICE TYPE]
Staff member: [STAFF NAME] (use "our team" if unknown)
Business owner name: [OWNER NAME]

Write a warm, genuine thank you email. 3–4 sentences. No review ask. No links.
Tone: friendly small business, not corporate.

Format:
SUBJECT: [subject line]
BODY: [email body]

Email 2 — Day 3: The Review Ask

Three days gives the customer time to reflect on their experience. They’ve had time to use the service, notice if the plumbing holds, see if the lawn looks good, feel whether their back is better. Sentiment at Day 3 is often higher than Day 0.

This email makes the direct ask. It references the earlier thank you (so it doesn’t feel cold), explains briefly why reviews matter to a small business, and includes the Google review link prominently.

The Day 3 email should:

Reference the previous thank you email naturally
Make a direct, confident ask (not a groveling one)
Explain the “why” in one sentence — reviews help small local businesses compete
Include the Google review link as a clear button or linked text
Stay under 100 words

Claude prompt for Day 3:

You are writing a Google review request email for [BUSINESS NAME].

This is a follow-up to a thank you email sent 3 days ago.
Customer first name: [FIRST NAME]
Service completed: [SERVICE TYPE]
Google review link: [REVIEW LINK]

Write a short, confident review request. Under 100 words. Reference the earlier thank you briefly.
Explain in one sentence why reviews matter to a small business.
The link should be included naturally in the body — label it "leave us a Google review" or similar.
Tone: genuine, direct, not pushy.

Format:
SUBJECT: [subject line]
BODY: [email body]

Email 3 — Day 7: The Final Nudge

One more email. This is the last one — make that clear in the copy so it doesn’t feel like the start of an endless sequence. Keep it very short. Lighter in tone. Easy to ignore without guilt.

Roughly 30% of the reviews that come from this sequence arrive after the Day 7 email. Many people genuinely intend to leave a review but forget. A brief, friendly nudge a week after the service is received well — especially when the copy makes it easy to action in under 30 seconds.

Claude prompt for Day 7:

You are writing a final review nudge email for [BUSINESS NAME].

Customer first name: [FIRST NAME]
Google review link: [REVIEW LINK]

Write a very short final email — 2 sentences maximum. This is the last email in the sequence.
Acknowledge it's a final nudge. Make it easy and guilt-free to ignore.
Include the review link.
Tone: light, low-pressure, human.

Format:
SUBJECT: [subject line]
BODY: [email body]

Building It: Claude Managed Agents + Gmail API

Here’s the technical stack and how the pieces connect.

What You Need

Anthropic API access with a key (claude-sonnet-4-6 is the right model — fast and accurate for this task)
Gmail API credentials via Google Cloud Console (OAuth2 for a business Gmail or Workspace account)
An automation layer: Make.com, n8n, or a lightweight Node.js/Python service

Step 1: Set Up the Claude Agent

Create a Claude agent using the Anthropic Messages API. For each email in the sequence, you’ll call the API with the appropriate prompt and the customer’s data fields injected.

import anthropic

client = anthropic.Anthropic(api_key="YOUR_API_KEY")

def generate_email(prompt_template: str, customer_data: dict) -> dict:
    filled_prompt = prompt_template.format(**customer_data)

    message = client.messages.create(
        model="claude-sonnet-4-6",
        max_tokens=512,
        messages=[{"role": "user", "content": filled_prompt}]
    )

    raw = message.content[0].text
    lines = raw.strip().split("\n")
    subject = lines[0].replace("SUBJECT:", "").strip()
    body = "\n".join(lines[2:]).replace("BODY:", "").strip()

    return {"subject": subject, "body": body}

Call this function three times — once per email — passing the relevant prompt and the customer’s data object. Store the outputs for scheduled delivery.

Step 2: Connect Gmail API

In Google Cloud Console, create a project, enable the Gmail API, and create OAuth2 credentials. Download the credentials JSON and run the local auth flow once to generate a refresh token. Store the refresh token securely — it’s what your automation uses to send email without re-authenticating.

from google.oauth2.credentials import Credentials
from googleapiclient.discovery import build
from email.mime.text import MIMEText
import base64

def send_email(to: str, subject: str, body: str, creds: Credentials):
    service = build("gmail", "v1", credentials=creds)

    message = MIMEText(body)
    message["to"] = to
    message["subject"] = subject

    encoded = base64.urlsafe_b64encode(message.as_bytes()).decode()
    service.users().messages().send(
        userId="me",
        body={"raw": encoded}
    ).execute()

Step 3: Wire the Trigger and Scheduling

In Make.com or n8n, build this flow:

Webhook trigger fires when a job is marked complete in the CRM
Claude API call generates all three emails from the customer data
Store email content in your database or a simple Google Sheet
Gmail send fires immediately for Day 0
Scheduled delay of 3 days, then send Day 3 email
Scheduled delay of 4 more days, then send Day 7 email

If you’re building this as a standalone Node.js service, use a job queue (BullMQ works well) to schedule the delayed sends. The queue persists across restarts and handles retry logic automatically.

What to Customize Per Client

If you’re building this as an agency service, each client deployment needs five variables configured:

1. Business Name and Type — feeds into every prompt. “Elite Plumbing” and “plumber” vs “Serenity Dental” and “dental practice” produce very different tone and copy.

2. Service Types — map your client’s service catalog to the trigger fields. “AC tune-up,” “drain cleaning,” “water heater replacement” — the more specific the service label passed to Claude, the more specific and credible the email copy.

3. Google Review Link — get this from the business’s Google Business Profile. Use the direct review URL (https://search.google.com/local/writereview?placeid=PLACE_ID) and put it through a link shortener for click tracking.

4. Staff Names — if the CRM tracks which technician or staff member completed the job, pass that field through. “Thanks for having Jake out today” outperforms “thanks for having our team out” every time.

5. Tone Setting — add a tone instruction to each prompt based on the business. A personal injury law firm needs different copy than a dog groomer. A single line like Tone: professional and reassuring, not casual is enough to steer Claude in the right direction.

How to Test Before Deploying

Never deploy an untested agent to a live client. Run this testing protocol first:

1. Generate 20 sample emails using real-ish test data — varied service types, different staff names, some with missing fields (staff unknown, service generic). Read every output. Look for hallucinated details, awkward phrasing, or tone that doesn’t match the business.

2. Send test emails to yourself across all three days in the sequence. Do the delays fire correctly? Do the emails land in inbox or spam? Does the Gmail “From” name display correctly?

3. Check the review link in every email template. A broken or wrong link is the single most costly error — you’ve gotten the customer to click and then sent them nowhere.

4. Simulate a missing-field case by leaving staff name blank or service type as null. Confirm your fallback copy kicks in gracefully (“our team” instead of a blank, “your recent service” instead of an empty field).

5. Get the client to approve sample emails before going live. Show them three example sequences with different service types. Adjusting tone before launch is trivial — adjusting it after customers have received emails that don’t sound right is a support headache.

Real World Results Expectations

When this sequence is deployed correctly — personalized copy, right timing, sent from a real business email address — you can expect:

Email open rate: 45–60% (transactional emails from a known sender open well)
Click-through rate on the review link: 25–35%
Completed reviews from clicks: 40–55%
Overall conversion rate (requests sent → published review): 10–20%

For a business completing 25 jobs per week, that’s 2–5 new Google reviews every week. In three months, you’ve added 25–65 reviews to a profile that may have had 30 total before. That’s a transformational change in how that business appears in local search.

The businesses I’ve built these for typically see their GBP impression count increase 30–60% within 90 days of deployment, driven partly by review velocity and partly by the engagement signals that come from more customers interacting with their profile after clicking through from the email.

One more thing worth noting: the Day 7 email consistently drives 25–35% of total reviews generated by the sequence. If you skip it to keep the sequence shorter, you’re leaving a third of your results on the table.

The Hardest Part Is Actually Connecting the Trigger

The Claude prompts and Gmail API integration are the easy parts. The variable in every deployment is the trigger — getting the “job complete” event out of whatever software the client is using.

Some platforms make this trivial. Jobber, ServiceTitan, and Housecall Pro all have webhooks or Zapier integrations that fire on job completion. Square and Stripe send clear payment-complete events. Google Workspace calendars can trigger on appointment end.

Others are messier. Legacy CRMs, custom-built systems, or clients who track jobs in a spreadsheet require more creative trigger solutions — a daily CSV export, a manual webhook from a Google Form, or a simple “completed jobs” API poll every few hours.

Budget time for this part. The technical trigger work often takes longer than the entire agent build.

Build It Yourself or Have It Done

If you have the technical background — comfortable with APIs, Python or Node.js, and basic automation tools — this build takes a competent developer one to two days for a single client deployment. The template is then reusable; subsequent clients take a few hours to configure and test.

If you’d rather have it built for you and handed over ready to run, that’s exactly what we do. Each deployment includes a custom Claude agent, Gmail API integration, Make.com scenario, client-specific prompt tuning, testing across 20 sample sequences, and a 30-day support window.

Enquire about a done-for-you Review Agent build: hello@seohq.app