# Google Local Services Ads Scraper (`khadinakbar/google-local-services-ads-scraper`) Actor

Find public Google Local Services advertisers by service and city for market research and prospecting. Returns name, rank, badge, reviews, public profile URL, source URL, and collection time. Excludes private Ads accounts, consumer leads, budgets, and messages. $0.009/query.

- **URL**: https://apify.com/khadinakbar/google-local-services-ads-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, SEO tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $70.00 / 1,000 completed local services advertiser lists

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Ads Scraper

Get a structured list of publicly visible Google Local Services advertisers for supported service categories in a United States city or district. Each record includes the advertiser’s rank, rating and reviews, phone when shown, service area, years in business, collection time, and public Google profile or source URL when the provider returns them.

### Best fit for this Actor

Use this Actor to build a sourced local-services prospect list, monitor category competition, or give an AI agent a clean advertiser dataset for a specific market. It uses a dedicated Google Local Services provider surface rather than treating ordinary Maps or organic results as ads. Its scope is public advertiser-card data; campaign accounts, consumer messages, budgets, and private lead records remain outside this workflow.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow for public Local Services advertiser research. Start with a service category and city CID, export the structured advertiser records, then pass the selected public profiles into your CRM, website research, or outreach-review process with their provenance intact.

### Quick start

```json
{
  "queries": ["electrician", "plumber"],
  "locationName": "Austin, Texas, United States",
  "dataCid": "6745062158417646970",
  "maxResults": 20,
  "languageCode": "en",
  "countryCode": "us"
}
```

`dataCid` is the decimal Google CID for the city or district. It is the authoritative market selector because Local Services availability depends on the precise market. Use the city or district CID rather than identifiers from individual-business or Place resources, and keep it as a string so all digits are preserved. `locationName` is the matching caller-supplied readable label carried into the output; pair it with the corresponding CID for the intended provider market. For example, Austin, Texas uses `6745062158417646970`.

Use the service category in `queries` and supply the city separately through `locationName` and `dataCid`. For example, send `"electrician"` with the Austin location fields. Add `jobType` when you have a supported Local Services job-type identifier, such as `"restore_power"` for an electrician query.

### Output data

Each dataset record represents one public advertiser returned for a category and city CID at collection time.

| Field | Meaning |
| --- | --- |
| `businessName` | Public advertiser name. |
| `advertiserRank` | Order in the returned Local Services advertiser list. |
| `googleBadge` | Public Google verification label when returned. |
| `rating` and `reviewCount` | Public rating and review volume. |
| `phone`, `serviceArea`, `yearsInBusiness` | Public card fields useful for prospect qualification. |
| `advertiserProfileUrl` | Public Google Local Services profile link when returned. |
| `locationDataCid` | Exact city or district CID used for the request. |
| `publicLeadSignals` | Transparent tags derived from public fields, never inferred intent. |
| `sourceUrl`, `sourceProcessedAt`, and `collectedAt` | Provenance, provider processing time, and Actor collection time for the record. |

```json
{
  "recordType": "local_services_advertiser",
  "query": "electrician",
  "locationName": "Austin, Texas, United States",
  "locationDataCid": "6745062158417646970",
  "businessName": "Abacus Electrical",
  "advertiserRank": 1,
  "rating": 4.8,
  "reviewCount": 6050,
  "phone": "+15125664985",
  "serviceType": "Electrician",
  "serviceArea": "Austin",
  "yearsInBusiness": 23,
  "advertiserProfileUrl": "https://www.google.com/localservices/profile?...",
  "publicLeadSignals": ["established_review_volume", "public_phone_available", "service_area_visible"],
  "dataSource": "serpapi_google_local_services",
  "sourceProcessedAt": "2026-08-24 12:00:00 UTC",
  "collectedAt": "2026-08-24T12:00:00.000Z"
}
```

`maxResults` limits saved advertiser rows for each category. A completed category can validly return no cards when Google has no current Local Services inventory for that service and city CID; the terminal `OUTPUT` record makes that outcome explicit.

### API workflow

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~google-local-services-ads-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries":["electrician"],"locationName":"Austin, Texas, United States","dataCid":"6745062158417646970","maxResults":20}'
```

Read `OUTPUT` before exporting the dataset. It reports the terminal outcome, returned-record count, query-event charges, durable per-query receipts, and any actionable warnings. `RUN_SUMMARY` holds safe provider diagnostics, source counts, and provenance metadata for the completed run. `QUERY_OUTCOMES` is the durable receipt list: the Actor writes each receipt, and any advertiser cards, before charging its matching completed-query event.

### Use with AI agents through Apify MCP

> Find public Google Local Services advertisers for electricians in Austin, Texas, United States. Use the city CID `6745062158417646970`, return up to 20 advertisers, and preserve business name, rank, rating, review count, public phone, service area, years in business, Google profile URL and source URL when returned, and collection time. Read the terminal output before using the dataset.

Use the current [Apify MCP setup](https://mcp.apify.com/) with your client. AI agents can send `searchQueries`, `location`, `data_cid`, `maxResultsPerQuery`, `language`, and `job_type` aliases; the Actor normalizes them to the same bounded request contract. Keep `locationDataCid`, `sourceProcessedAt`, and `collectedAt` in every downstream CRM or outreach workflow, plus `sourceUrl` when the provider returns a public source link.

### Pricing

This Actor uses Pay per event plus Apify platform usage. It charges **$0.07 for each successfully completed Local Services category and city-CID query** and **$0.00005 per Actor start**. It makes the matching advertiser cards (or a durable valid-empty receipt) available before charging the completed-query event. One category query costs $0.07 plus the start event and platform usage; ten category queries cost at most $0.70 in query events. A caller-set cap below the first-query amount yields `CONFIG_ERROR` with `stopReason: "charge_limit"` before the provider request; a cap reached after useful work yields `PARTIAL` with that same stop reason. When the platform leaves a post-persistence event unconfirmed, the available receipt stays `not_charged`, collection stops, and the run returns `PARTIAL` with `stopReason: "billing_unconfirmed"`. Check the live Pricing tab for the current effective rate before scheduling a large collection.

### Best results

- Use a supported Local Services category such as electrician, plumber, HVAC, locksmith, roofer, or appliance repair.
- Use a city or district CID; city-level CIDs produce the most consistent list coverage.
- Run each market and service category independently when you need a clear competitive snapshot.
- The Actor requests a fresh provider response for each completed query. Keep `sourceProcessedAt` and `collectedAt`, plus `sourceUrl` when available, to keep each observation traceable.

### Builder's note

I designed this Actor around the dedicated Local Services advertiser surface so the output remains an advertiser list rather than a mixture of Maps listings and organic results. The category-and-city-CID request is the billable unit, giving agencies and AI workflows a known upper bound before collection while retaining provider timestamps and any public source link returned for each record.

### Responsible use

Use public business information in line with applicable laws, Google and provider terms, and your own outreach obligations. This workflow supports market research and responsible business prospecting.

# Actor input Schema

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

One to ten supported Local Services category queries, for example \["electrician", "plumber"]. Enter the service only; set the market separately with locationName and dataCid. Each completed category and city-CID request is billed once.

## `locationName` (type: `string`):

Caller-provided readable label for the same United States city or district represented by dataCid, for example "Austin, Texas, United States". dataCid is the authoritative provider market selector; this matching label is carried into every output record for CRM and agent workflows.

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

Required decimal Google CID for the requested city or district, not a business CID or a Google Place ID. Use it exactly as a string to preserve all digits. Example: Austin, Texas is "6745062158417646970". The Actor validates it so it never substitutes a different market.

## `maxResults` (type: `integer`):

Maximum public advertiser records to save for each category query. The dedicated source can return up to 20 cards per category; this cap controls dataset size, not the number of billed category queries.

## `languageCode` (type: `string`):

Two-to-five-letter Google interface language code, such as "en" or "es". It defaults to en and is included in the provider request.

## `countryCode` (type: `string`):

The dedicated Google Local Services provider source currently supports United States city and district CIDs. Keep this set to us.

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

Optional supported Local Services job-type identifier, for example "restore\_power" with electrician. Leave blank to collect the category-level advertiser list. The same job type applies to all queries in this run.

## Actor input object example

```json
{
  "queries": [
    "electrician"
  ],
  "locationName": "New York, New York, United States",
  "dataCid": "6745062158417646970",
  "maxResults": 20,
  "languageCode": "en",
  "countryCode": "us",
  "jobType": "restore_power"
}
```

# Actor output Schema

## `results` (type: `string`):

One normalized public Local Services advertiser record per dataset item.

## `output` (type: `string`):

Stable terminal outcome, counts, charges, durable query receipts, and warnings.

## `queryOutcomes` (type: `string`):

Safe per-query receipt list persisted before its matching completed-query event is charged.

## `runSummary` (type: `string`):

Detailed safe diagnostics and provider request outcomes.

# 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 = {
    "queries": [
        "electrician"
    ],
    "locationName": "Austin, Texas, United States",
    "dataCid": "6745062158417646970",
    "maxResults": 20,
    "languageCode": "en",
    "countryCode": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/google-local-services-ads-scraper").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 = {
    "queries": ["electrician"],
    "locationName": "Austin, Texas, United States",
    "dataCid": "6745062158417646970",
    "maxResults": 20,
    "languageCode": "en",
    "countryCode": "us",
}

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

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "electrician"
  ],
  "locationName": "Austin, Texas, United States",
  "dataCid": "6745062158417646970",
  "maxResults": 20,
  "languageCode": "en",
  "countryCode": "us"
}' |
apify call khadinakbar/google-local-services-ads-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/google-local-services-ads-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/x5gKZkXwagh1WR6sK/builds/rUXlxoo3KU7t4b01Z/openapi.json