How to Automate Address Verification in TryRating Using AI (ChatGPT, Claude & Gemini)

Stop opening Google Maps for every result. Here's how to build a reusable AI workflow for address verification — with accurate setup instructions for ChatGPT GPTs, Claude Projects, and Gemini Gems.

If you work as a Data Analyst on TryRating, address verification is one of the most repetitive parts of the job. You see an address, open Google Maps, search it, check whether the business exists, compare the name, look for signs it has closed — then do it all again for the next result.

On a busy session, that repetition eats a significant chunk of your capped weekly hours.

This guide shows you how to automate most of that using AI. You paste an address, optionally add a business name, and get a structured result in seconds. I'll cover three platforms — ChatGPT GPTs, Claude Projects, and Gemini Gems — accurately describing what each platform can and can't do for this workflow.

Don't want the technical setup? The Address Checker is built directly into Rater Sidekick for Plus and Pro subscribers. You paste the address into the app, it calls the backend for you, and returns the result with a Google Maps link — no API keys, no custom GPT, no deployment required.

What the Checker Does

You give it two inputs:

The address
Optionally, the business name

It returns a structured result like this:

Normalized address: 123 Main Street, Dublin 1, Ireland
Address format: OK
Business exists: Yes
Open status: Open
Canonical name: The Coffee Dock
Name match score: Strong match
Discrepancies: None
Sources: [Google Maps link] | [Foursquare link]

In one paste you know: does the address exist, is there a business there, does the name match, is it still open. For uncertain cases, the source links let you jump straight to manual verification — no searching.

From my own use, accuracy is around 95% across English-language locales. That's a personal estimate, not a universal benchmark — always manually review low-confidence results.

How It Works Behind the Scenes

The workflow has two layers:

An AI assistant that accepts your input and formats the result
A backend endpoint that queries live location data providers

The backend pattern is:

Use geocoding to normalize the address
Query a places API to find the business
Cross-reference with a second provider
Return a structured JSON response with a confidence score

A good backend queries both Google Places and Foursquare, compares the two, and returns a verdict with map links. More on that in Part 1 below.

The Easy Option: Rater Sidekick Plus and Pro

If you are on Rater Sidekick Plus or Pro, this feature is already included — no setup required.

You don't need to:

Create a custom GPT
Import an OpenAPI schema
Deploy a Cloudflare Worker
Manage Google or Foursquare API keys

Just paste the address into the Rater Sidekick interface, optionally add the business name, and get the result directly — including a Google Maps link when available.

For most raters, this is the practical option. The DIY route below is for people who want to understand the workflow or build their own version.

Part 1: Build the Backend (Self-Hosted)

All live AI integrations need a backend endpoint to call. The lightest option is a Cloudflare Worker, which runs serverless functions for free up to 100,000 requests/day on the free tier.

1.1 Get Your API Keys

Google Maps API:

Go to console.cloud.google.com
Create a new project (e.g. tryrating-checker)
In the API Library, enable the Places API and Geocoding API
Go to Credentials → Create API Key
Restrict the key to those two APIs only
Save the key — you'll need it in Step 1.3

Foursquare Places API:

Go to foursquare.com/developer
Sign up and create a new project
Copy your API key from the dashboard

1.2 The Request and Response Shape

Your backend should accept a POST request with this body:

{
  "address": "1 Infinite Loop, Cupertino, CA",
  "name": "Apple",
  "country_hint": "US"
}

And return a response including:

normalized_address
address_format_ok and address_issues
place_exists
is_currently_open (open / closed / unknown)
canonical_name and name_match_score
Google and Foursquare source links
confidence score and notes

1.3 Deploy to Cloudflare Workers

Create a free account at cloudflare.com
Go to Workers & Pages → Create Worker
Name it (e.g. tryrating-address-proxy)
Click Edit Code and paste your worker script
Go to Settings → Variables and add:
- GOOGLE_API_KEY = your Google key
- FOURSQUARE_API_KEY = your Foursquare key
Click Save and Deploy

Your endpoint will be at: https://your-worker-name.your-subdomain.workers.dev/verify-location

Test this endpoint directly (via curl or Postman) before connecting it to any AI assistant. The AI layer is only as reliable as the backend it calls.

Part 2: ChatGPT Custom GPT (Recommended for Live API Calls)

ChatGPT is currently the clearest platform for a fully documented live tool integration. OpenAI explicitly supports custom GPTs with Actions, configured via OpenAPI schemas. You need a ChatGPT Plus, Pro, Team, Enterprise, or Edu subscription to create GPTs.

Step 1: Create the GPT

In ChatGPT, click your profile picture → My GPTs → Create a GPT
Switch to the Configure tab
Set the Name to: TryRating Address Checker
Set the Description to: Verifies business addresses for TryRating map tasks

Step 2: Add the Instructions

In the Instructions field, paste the following. The goal is to make it behave like a utility tool, not a general-purpose assistant:

When a user provides an address (and optionally a business name), always call verifyLocation.

Return results in this exact structure:

Normalized address: …
Address format: OK / Issues: …
Business exists: Yes/No
Open status: open/closed/unknown
Canonical name: …
Name match score: … (strong/partial/weak match)
Discrepancies: …
Sources: [Google Maps link] | [Foursquare link]

Do not browse the web. Rely on the Action output only.
If the Action fails or returns an error, say so clearly and suggest manual verification.
Keep output concise and consistent — no extra commentary unless the user asks.

Step 3: Add the Action

Scroll to the Actions section and click Add Action. In the Schema field, paste the following (replace the server URL with your own Worker URL):

openapi: 3.1.0
info:
  title: Verify Location Proxy
  version: "1.1.0"
servers:
  - url: https://your-worker-name.your-subdomain.workers.dev
paths:
  /verify-location:
    post:
      operationId: verifyLocation
      x-openai-isConsequential: false
      summary: Verify a business location using Google and Foursquare
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              required:
                - address
              properties:
                address:
                  type: string
                  description: Full street address to verify
                name:
                  type: string
                  description: Optional business name
                country_hint:
                  type: string
                  description: Optional 2-letter country code (e.g. US, IE, GB)

Click Save in the top right.

Step 4: Test With Known Cases

Before using this in real tasks, test at least four scenarios:

A well-known business that definitely exists
A valid address with no business name provided
A business that has permanently closed
A messy or incomplete address

This gives you a realistic baseline for where the workflow is reliable and where to apply manual review.

Part 3: Claude Projects

Claude Projects are a good fit for a reusable address-checking workspace — a persistent assistant with fixed instructions, consistent output format, and ongoing chat history scoped to the task.

It's important to be accurate about what Projects do and don't provide here. As of now, Claude Projects do not have a built-in no-code form for connecting arbitrary external REST APIs the way ChatGPT GPT Actions do. Anthropic documents external tool connectivity separately through MCP (Model Context Protocol) connectors, which is a developer-level integration path.

What Projects are excellent for:

Storing your instructions and output format permanently so you don't re-explain them each session
Uploading reference documents (e.g. address format guidelines for your locale)
Keeping a consistent, task-focused assistant across multiple work sessions

Step 1: Create a Project

Go to claude.ai
In the left sidebar, click Projects → New Project
Name it TryRating Address Checker

Step 2: Add Project Instructions

Click Edit project instructions and paste:

You help verify business addresses for TryRating map analyst tasks.

When given an address and optionally a business name, return your assessment in this structure:

Normalized address: …
Address format: OK / Issues: …
Business exists: (your assessment based on the information provided)
Open status: open/closed/unknown
Canonical name: …
Name match score: strong/partial/weak/unable to assess
Discrepancies: …
Sources: (list any links the user has provided)

Be concise. Flag uncertainty clearly rather than guessing.
If you do not have live location data, say so — do not fabricate results.

Step 3: How to Use It Effectively

Because Claude in a Project does not have live API access out of the box, the practical workflow is slightly different:

Option A — Paste the result manually: Run your backend query separately (via curl, Postman, or a simple script), copy the JSON output, and paste it into Claude. Claude will format and interpret it for you using the project instructions.

Option B — Use Claude alongside the Rater Sidekick checker: Use Rater Sidekick's built-in Address Checker to get the live result, then use your Claude Project for any follow-up reasoning, flagging patterns, or drafting notes.

Option C — Developer path via MCP: If you want Claude to call your endpoint directly, Anthropic's MCP (Model Context Protocol) allows Claude to connect to remote tools. This requires developer setup. See Anthropic's MCP documentation for details.

For most raters, Option A or B is the right call. The Project still adds real value — consistent output format, persistent instructions, and no re-prompting every session.

Part 4: Gemini Gems

Gemini Gems let you create a reusable custom assistant with fixed instructions and a name — Google's equivalent of a persistent task-focused persona.

Again, accuracy matters here. Gemini Gems are custom assistants, not a no-code API integration layer. Live function calling in Gemini is a developer feature accessed through the Gemini API, not something you configure in the Gems UI on gemini.google.com. Google documents Gems and function calling separately.

What Gems are excellent for:

A reusable, consistently instructed address-checking assistant
Getting structured output from information you paste in
Combining with Google Search grounding for basic business lookups

Step 1: Create a Gem

Go to gemini.google.com
Click Explore Gems → New Gem
Name it TryRating Address Checker

Step 2: Add Instructions

You help verify business addresses for TryRating map analyst tasks.

When given an address and optionally a business name, return your assessment in this structure:

Normalized address: …
Address format: OK / Issues: …
Business exists: (your assessment)
Open status: open/closed/unknown
Canonical name: …
Name match score: strong/partial/weak/unable to assess
Discrepancies: …
Sources: (list any links or sources you used)

Keep the output concise and structured.
Do not fabricate business status or source links.
If you are not confident, say so clearly.

Step 3: Enable Google Search Grounding (Optional)

In your Gem settings, you can enable Google Search as a grounding tool. This allows Gemini to search for real-time business information to inform its response — useful for well-known businesses, though less reliable than a structured API call for precise address verification.

This is not the same as calling your Cloudflare backend, but it does give Gemini access to live data for common lookups.

Step 4: How to Use It

The workflow is similar to Claude:

For full live API results, query your backend separately and paste the output into the Gem for formatting and interpretation
For common businesses, enable Google Search grounding and let Gemini do a best-effort lookup
For developer-level live function calling with your own backend, use the Gemini API directly

Day-to-Day Workflow

Whichever platform you use, the practical session flow is the same:

Open the TryRating task
Copy the address and business name if shown
Paste into your checker (Rater Sidekick, ChatGPT GPT, or your chosen AI)
Read the structured result
Click the source link only when the result looks uncertain or the confidence is low

You're not replacing your judgement — you're eliminating the repetitive lookup step for the majority of results so you can focus attention where it's actually needed.

Limitations to Keep in Mind

No automated workflow is perfect. Common failure cases:

Very new businesses not yet in provider databases
Recently closed businesses with stale listings
Rebrands or abbreviations that produce weak name match scores even when correct
Rural or low-coverage areas with thinner Foursquare data
Multi-tenant buildings or campus addresses that resolve ambiguously

For any result where the name match score is weak, confidence is low, or discrepancies are flagged — click through and verify manually.

Summary: Which Platform for What

Platform	Live API calls	Best use for raters
ChatGPT GPT	✅ Via GPT Actions (OpenAPI)	Full live lookup workflow
Claude Project	Via MCP (developer setup)	Persistent instructions + paste-in results
Gemini Gem	Via Gemini API (developer)	Reusable assistant + Search grounding
Rater Sidekick	✅ Built-in, no setup	Fastest path, no configuration needed

If you want a fully automated live workflow without writing code, ChatGPT GPT Actions is currently the most accessible documented path. If you just want the benefit without any setup at all, that's what Rater Sidekick Plus and Pro are for.

Published on the Rater Sidekick blog — tools and tips for TryRating map analysts. ratersidekick.com