# Google Local Services API | Local Services Ads & Lead Gen (`johnvc/google-local-services-api`) Actor

Search Google Local Services Ads: Google Guaranteed and Google Screened home-service pros with ratings, reviews, and phone numbers as clean JSON. Built for local SEO agencies, home-services lead gen, and competitor tracking. Pay per business returned. MCP-ready for Claude and AI agents.

- **URL**: https://apify.com/johnvc/google-local-services-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** Lead generation, SEO tools, MCP servers
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.70 / 1,000 business returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Google Local Services API | Local Services Ads & Lead Gen

> **Search Google Local Services Ads - the "Google Guaranteed" pros above the map pack - and get clean, structured JSON back.**

Google Local Services Ads are the sponsored home-service listings that appear at the very top of Google when someone searches "plumbers near me": vetted businesses carrying the **Google Guaranteed** or **Google Screened** badge, with ratings, review counts, and phone numbers. This API returns that listing for any service in any US city, as flat JSON rows ready for lead-gen pipelines, local SEO dashboards, and AI agents.

No browser automation, no proxies to configure, no HTML to parse.

### What you get for every business

| Field | Description |
|---|---|
| **Identity** | Business name, business type (e.g. Electrician), profile link, thumbnail |
| **Trust badges** | `googleGuaranteed` and `googleScreened` booleans, plus the raw badge text |
| **Reputation** | Average star rating and total review count |
| **Contact** | Phone number in international format |
| **Coverage** | Service area, years in business, recent bookings nearby |
| **Hours** | Current open status and the weekly hours table |
| **IDs** | Stable business IDs (`cid`, `bid`, `pid`) plus the place `dataCid` for repeat runs |
| **Summary** | A one-line human-readable summary built for AI agents |

### Use cases

- **Home-services lead generation** - pull every Google Guaranteed plumber, electrician, roofer, or HVAC company in a metro, with phone numbers.
- **Local SEO and LSA monitoring** - track which businesses hold the top Local Services slots for your clients' keywords, week over week.
- **Competitor tracking** - watch a competitor's rating, review velocity, and badge status across the cities they serve.
- **Market research** - compare provider density, ratings, and years-in-business across cities before entering a market.
- **Agency prospecting** - find home-service businesses that are NOT yet running Local Services Ads by diffing against business directories.

### Input

Provide at least one service query, plus a location (or a `dataCid`).

```json
{
  "queries": ["plumbers", "electricians"],
  "location": "Austin, TX"
}
````

| Parameter | Type | Notes |
|---|---|---|
| `query` / `queries` | string / array | The service(s) to search, e.g. "plumber", "electrician", "hvac", "dentist", "personal injury lawyer". At least one required. Google supports a fixed list of about 109 service types; plurals and common phrasings are normalized automatically ("plumbers" works), and unsupported queries return the closest supported matches so you can retry. |
| `location` | string | US city or district, e.g. "Austin, TX". Resolved internally to the Google place ID. |
| `dataCid` | string | Advanced: pass the decimal Google place CID directly and skip location resolution (and its fee). Every result row includes the `dataCid`, so you can copy it from a previous run. |
| `jobType` | string | Optional service subcategory, e.g. `restore_power` for electricians. |
| `language` | string | Two-letter language code, default `en`. |
| `maxResultsPerQuery` | integer | Optional cap per query; a listing typically returns up to about 20 businesses. |

Note: Google serves Local Services Ads for **US locations only**.

### Example output

```json
{
  "result_type": "local_services_ad",
  "query": "electrician",
  "location": "Austin, TX",
  "dataCid": "6745062158417646970",
  "businessName": "Tejas Electric",
  "badge": "GOOGLE GUARANTEED",
  "googleGuaranteed": true,
  "googleScreened": false,
  "rating": 5.0,
  "reviews": 255,
  "phone": "+15128587689",
  "businessType": "Electrician",
  "serviceArea": "Austin",
  "yearsInBusiness": 8,
  "hours": { "currently": "Open 24 hours" },
  "profileLink": "https://www.google.com/localservices/profile?cs=0&q=Tejas+Electric",
  "summary": "Tejas Electric - Electrician - serving Austin - 5.0 stars (255 reviews) - Google Guaranteed",
  "fetched_at": "2026-07-06T15:37:00+00:00"
}
```

### Pricing

Pay-per-event: you are charged for each business returned, so cost scales with the data you actually receive.

| Event | When it is charged |
|---|---|
| Business returned | Once for every Local Services business row in your dataset |
| Location resolved | Once for each unique `location` string resolved to a Google place. Skipped entirely when you pass `dataCid` directly |

Tip: after the first run for a city, copy the `dataCid` from any result row and use it in future runs to avoid the resolution fee.

### How to get started

1. [View on Apify Store](https://apify.com/johnvc/google-local-services-api?fpr=9n7kx3) and click **Try for free**.
2. Enter a service (e.g. "plumbers") and a US city (e.g. "Austin, TX").
3. Run it and download your results as JSON, CSV, or Excel, or read them via the API.

Looking for the organic map pack instead of the sponsored Local Services listing? Use the [Google Local API](https://apify.com/johnvc/google-local-api?fpr=9n7kx3).

### 🔌 Use this API from Claude (MCP)

Add this actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), or any other MCP client, via the hosted Apify MCP server. Use this actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/google-local-services-api

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

Then ask things like: *"Pull every Google Guaranteed electrician in Austin with their phone numbers and put them in a table."*

### FAQ

#### Why did I get no results for my city?

Google Local Services Ads only run in the United States, and only for service categories where Google has vetted providers. Try a larger nearby metro or a more common service term (e.g. "plumber" instead of a niche specialty).

#### Which services can I search for?

Google runs Local Services Ads for a fixed set of about 109 service types across home services (plumber, electrician, hvac, roofer, landscaper, pest control...), legal (personal injury lawyer, immigration lawyer, dui lawyer...), health (dentist, chiropractor, optometrist...), pets, beauty, auto, and education. Plurals and common phrasings are normalized automatically. If a query is not supported, the run returns a `no_results` row listing the closest supported service types, so agents can self-correct and retry.

#### What is the difference between Google Guaranteed and Google Screened?

Google Guaranteed covers home services (plumbers, electricians, HVAC) and includes a money-back guarantee for consumers. Google Screened covers professional services (lawyers, financial planners) and verifies licenses and background checks. Both are returned by this API with a dedicated boolean field.

#### How is this different from the Google Local / Maps pack?

The Local Services listing is a separate, sponsored program with vetted-provider badges and lead-gen phone numbers. The map pack is the organic local result. This API returns the former; the [Google Local API](https://apify.com/johnvc/google-local-api?fpr=9n7kx3) returns the latter.

#### Can I look up one specific business?

Not yet. Per-business profile lookups (via the `cid`/`bid`/`pid` IDs each row includes) are on the roadmap. If you need this, open an issue on the actor page.

Last Updated: 2026.07.06

# Actor input Schema

## `query` (type: `string`):

REQUIRED (or use `queries`). The service to search for, e.g. 'plumber', 'electrician', 'hvac', 'personal injury lawyer', 'dentist', 'roofer'. Google supports a fixed list of about 109 service types; common phrasings and plurals are normalized automatically, and unsupported queries return the closest supported matches.

## `queries` (type: `array`):

Provide a list of services to search in one run, e.g. \['plumber', 'electrician', 'roofer']. Each query is one Local Services Ads listing for the same location.

## `location` (type: `string`):

The US city or district to search in, e.g. 'Austin, TX' or 'Brooklyn, NY'. Resolved internally to the Google place ID (one billed resolution for each unique location). Google Local Services Ads cover US locations only. Leave empty if you pass `dataCid` instead.

## `dataCid` (type: `string`):

Advanced: the decimal Google CID of a city or district level place, e.g. '6745062158417646970' for Austin, TX. When set, `location` is ignored and no location-resolution fee is charged.

## `jobType` (type: `string`):

Optional subcategory of the service, e.g. 'restore\_power' for electricians or 'unclog\_drain' for plumbers. Narrows the listing to providers offering that specific job.

## `language` (type: `string`):

Two-letter language code for the results, e.g. 'en' or 'es'. Defaults to 'en'.

## `maxResultsPerQuery` (type: `integer`):

Optional cap on how many businesses to return for each query (a listing typically returns up to about 20). Leave empty to return all businesses found.

## Actor input object example

```json
{
  "query": "plumber",
  "location": "Austin, TX",
  "language": "en"
}
```

# Actor output Schema

## `allResults` (type: `string`):

All dataset items from this run, including any no\_results or error rows.

## `businesses` (type: `string`):

The Local Services businesses table view.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "query": "plumber",
    "location": "Austin, TX",
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/google-local-services-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "query": "plumber",
    "location": "Austin, TX",
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/google-local-services-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "query": "plumber",
  "location": "Austin, TX",
  "language": "en"
}' |
apify call johnvc/google-local-services-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=johnvc/google-local-services-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Local Services API | Local Services Ads & Lead Gen",
        "description": "Search Google Local Services Ads: Google Guaranteed and Google Screened home-service pros with ratings, reviews, and phone numbers as clean JSON. Built for local SEO agencies, home-services lead gen, and competitor tracking. Pay per business returned. MCP-ready for Claude and AI agents.",
        "version": "0.0",
        "x-build-id": "XSNL9lGf5M2XjLCf3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/johnvc~google-local-services-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-johnvc-google-local-services-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/johnvc~google-local-services-api/runs": {
            "post": {
                "operationId": "runs-sync-johnvc-google-local-services-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/johnvc~google-local-services-api/run-sync": {
            "post": {
                "operationId": "run-sync-johnvc-google-local-services-api",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Service Query",
                        "type": "string",
                        "description": "REQUIRED (or use `queries`). The service to search for, e.g. 'plumber', 'electrician', 'hvac', 'personal injury lawyer', 'dentist', 'roofer'. Google supports a fixed list of about 109 service types; common phrasings and plurals are normalized automatically, and unsupported queries return the closest supported matches."
                    },
                    "queries": {
                        "title": "Service Queries",
                        "type": "array",
                        "description": "Provide a list of services to search in one run, e.g. ['plumber', 'electrician', 'roofer']. Each query is one Local Services Ads listing for the same location.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location (US city or district)",
                        "type": "string",
                        "description": "The US city or district to search in, e.g. 'Austin, TX' or 'Brooklyn, NY'. Resolved internally to the Google place ID (one billed resolution for each unique location). Google Local Services Ads cover US locations only. Leave empty if you pass `dataCid` instead."
                    },
                    "dataCid": {
                        "title": "Google Place CID (advanced)",
                        "type": "string",
                        "description": "Advanced: the decimal Google CID of a city or district level place, e.g. '6745062158417646970' for Austin, TX. When set, `location` is ignored and no location-resolution fee is charged."
                    },
                    "jobType": {
                        "title": "Job Type",
                        "type": "string",
                        "description": "Optional subcategory of the service, e.g. 'restore_power' for electricians or 'unclog_drain' for plumbers. Narrows the listing to providers offering that specific job."
                    },
                    "language": {
                        "title": "Language Code",
                        "type": "string",
                        "description": "Two-letter language code for the results, e.g. 'en' or 'es'. Defaults to 'en'.",
                        "default": "en"
                    },
                    "maxResultsPerQuery": {
                        "title": "Max Businesses Per Query",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Optional cap on how many businesses to return for each query (a listing typically returns up to about 20). Leave empty to return all businesses found."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
