# Google Maps Leads Scraper: No Website, Unclaimed (`steady-scrape/google-maps-business-segments`) Actor

Google Maps leads scraper with filters: local businesses with no website, unclaimed profiles, low ratings, few reviews or recently listed, by category and area. Filters run server-side, so you pay only for matches. Freshness dates on every record, no emails. From $0.002 per business.

- **URL**: https://apify.com/steady-scrape/google-maps-business-segments.md
- **Developed by:** [SteadyScrape](https://apify.com/steady-scrape) (community)
- **Categories:** Lead generation, Marketing, SEO tools
- **Features:** Limited permissions
- **Stats:** 5 total users, 2 monthly users, 95.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 businesses

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Google Maps Leads Scraper: No Website, Unclaimed

**Who it's for:** Web designers, local SEO and marketing agencies and sales teams looking for local businesses that need help online.

**What you get:** Filtered Google Maps business lists: businesses with no website, soon-to-open and newly listed businesses, unclaimed profiles, low ratings or few reviews, with name, category, address, phone, rating, reviews and a freshness date.

**Price:** $0.005 per business that matches a filter ($0.002 per business with no filter) plus $0.015 per run. Empty runs are free.

Build **filtered Google Maps business lists** in one run: every plumber in Austin **without a website**, every **unclaimed** dentist profile within 15 km, restaurants rated **below 4 stars**, salons with **fewer than 10 reviews**, or listings **first seen in the last 60 days**.

The filters run on the data provider's side, so you only get (and only pay for) the businesses that match. You don't pay to scrape all of Maps and throw most of it away.

### One-click lead presets (new)

Pick a preset in **Lead preset** and add a category and an area. That's the whole setup.

| Preset | What it returns | Typical buyer |
|---|---|---|
| `noWebsite` | Businesses with **no website** on their Google profile | Web designers, website builders, local SEO |
| `soonToOpen` | **Soon-to-open and newly listed** businesses: first seen in the last 90 days with no reviews yet, newest first | POS, payments, insurance, signage, suppliers, local marketers |

```json
{ "categories": ["restaurant"], "coordinates": "30.2672,-97.7431", "radiusKm": 20, "leadPreset": "soonToOpen", "maxResults": 50 }
```

Presets only set the matching filters, so you can still add more (for example `noWebsite` + `claimStatus: unclaimed`). Your own *First seen* or *Fewer reviews than* values override the `soonToOpen` defaults. Both presets are segment lists and use the segment price below. Records whose name or description says "coming soon", "opening soon", "grand opening", "próximamente", "próxima apertura", "ouverture bientôt" or "prochainement" also get the `opening-soon-text` tag.

### Canada: city presets and French (new)

Pick a **Canadian city preset** (Toronto, Montréal, Vancouver, Calgary, Ottawa, Edmonton, Winnipeg, Québec City, Mississauga, Hamilton, Brampton, Surrey, Laval, Gatineau, Halifax, Victoria, Kitchener-Waterloo, London ON, Saskatoon, Regina, Sherbrooke, Longueuil) and the Actor fills in the city-centre coordinates and `countryCode: CA`. Set **Radius (km)** for the area you want; the form shows a suggested whole-city radius for each city.

French category names work as input: `toiture` / `couvreur` (roofing contractor), `revêtement extérieur` (siding), `coiffure` (hair salon), `plombier`, `électricien`, `dentiste`, `paysagiste`, `garderie` and more. The run log shows how each French name was mapped. French "opening soon" wording (`ouverture bientôt`, `prochainement`, `grande ouverture`, `nouvelle ouverture`, `ouverture le 5 décembre`…) also sets the `opening-soon-text` tag.

```json
{ "categories": ["toiture", "revêtement extérieur"], "cityPreset": "ottawa", "radiusKm": 25, "leadPreset": "noWebsite", "maxResults": 100 }
```

```json
{ "categories": ["restaurant", "café"], "cityPreset": "montreal", "radiusKm": 15, "leadPreset": "soonToOpen", "maxResults": 50 }
```

Same prices as every other run. Contacting Québec businesses? Consider `dropPhones` for sole traders (Law 25), and follow CASL for any outreach.

Made by **SteadyScrape (steady-scrape)**. Note: we are not the similarly named "steadyscrape" account on Apify.

### What you can do with it

| Segment | Who uses it | Pitch it enables |
|---|---|---|
| **No website** (or only a Facebook/Instagram/Yelp page) | Web design agencies, website builders | "You have no website, and customers search for you on Google." |
| **Unclaimed profile** | Local SEO agencies, GBP management tools | "Your Google profile is unclaimed. Anyone can suggest edits to it." |
| **Rating below X** | Review management and reputation SaaS | "Your 3.6★ rating is costing you calls." |
| **Fewer than Y reviews** | Review-generation tools, local marketers | "Your competitors have 10× more reviews." |
| **Soon to open / first seen recently** | Suppliers, POS/payment vendors, insurers | "Welcome to the neighbourhood." (see the caveat below) |
| **Status** | Market analysts, franchise scouts | Temporarily or permanently closed businesses in an area |

You can combine filters, for example *unclaimed + no website + fewer than 5 reviews*.

### Input

- **Categories:** 1–10 Google Maps categories (`plumber`, `dentist`, `roofing_contractor`, `hair_salon`, `restaurant`, `auto_repair_shop`…). Spaces and capitals are fine. A misspelt category fails right away, with suggestions, and costs nothing.
- **Location:** use one of these:
  - **Canadian city preset** (one click, see the Canada section above).
  - **Coordinates + radius** (recommended): `30.2672,-97.7431` with `15` km. This catches suburbs that a city name misses.
  - **City** (exact name as written in the address; lowercase input is auto-capitalised) plus **country code**.
  - **Postal code**, or a **country code** alone for country-wide lists.
- **Lead preset:** `noWebsite` or `soonToOpen` (optional, see above).
- **Segment filters:** website, claim status, rating below, fewer reviews than, first seen in the last N days.
- **Other filters:** business status (defaults to *operating*, which excludes temporarily and permanently closed businesses), rating at least, minimum reviews, record refreshed in the last N days.
- **Output:** max businesses (up to 10,000 per run), sort order, drop phones, include hours, include attributes.

Example: *Austin plumbers with no website and an unclaimed profile, within 25 km*

```json
{
  "categories": ["plumber"],
  "coordinates": "30.2672,-97.7431",
  "radiusKm": 25,
  "website": "noWebsite",
  "claimStatus": "unclaimed",
  "maxResults": 200
}
```

### Output

One record per business:

- **Business:** name, main and additional categories, description (email addresses masked), price level.
- **Location:** full address and its parts (street, city, postal code, region, country), latitude and longitude, Google `placeId` and `cid`, and a Google Maps link.
- **Website:** URL and domain, `hasWebsite`, and `websiteIsSocialProfile` (true when the "website" is just a Facebook or Instagram page).
- **Business phone:** from the Google profile. Set `dropPhones` to remove it. That also masks phone-like numbers in the description.
- **Profile:** `isClaimed`, rating, review count, 1–5★ distribution, photo count, `hasLogo`.
- **Status and hours:** current status and weekly opening hours.
- **Extras:** Google attributes (delivery, wheelchair access…), review topic keywords, and booking or ordering links.
- **`segmentTags`:** which segments the business falls into, e.g. `no-website`, `unclaimed`, `no-reviews`, `rating-below-4`, `likely-new-or-opening-soon` (first seen recently, no reviews yet, not closed) and `opening-soon-text` (the name or description says "coming soon", "opening soon" or "grand opening").
- **Freshness:** `lastUpdatedTime` (when the database last refreshed the record), `firstSeen` (when the provider's crawler first found it), and `dataAgeDays`.

```json
{
  "name": "Example Plumbing Co",
  "category": "Plumber",
  "city": "Austin",
  "postalCode": "78727",
  "countryCode": "US",
  "phone": "+1512-000-0000",
  "website": null,
  "hasWebsite": false,
  "isClaimed": false,
  "rating": 4.8,
  "reviewsCount": 27,
  "businessStatus": "open",
  "segmentTags": ["no-website", "unclaimed"],
  "lastUpdatedTime": "2026-09-12T20:57:59Z",
  "firstSeen": "2024-07-14T17:54:36Z",
  "dataAgeDays": 45,
  "googleMapsUrl": "https://www.google.com/maps?cid=..."
}
```

A run summary (number of matches in the database, filters used, charges) is saved to the `OUTPUT` record in the key-value store. Export the dataset as CSV, Excel or JSON, or pull it over the API.

#### What we deliberately leave out

- **No email addresses.** We drop the provider's contact list (emails and extra phone numbers scraped from other websites) and mask emails found in descriptions.
- **No owner or person names, no reviewer data, no photos.**
- **Phone is optional.** The business phone is the number the business published on its own Google profile. Turn on `dropPhones` if you don't need it. We recommend turning it on if you target sole traders in the EU, UK or Quebec, where a one-person business's phone can count as personal data.

### Data freshness: please read

This Actor queries a **regularly refreshed database of Google Maps listings** (licensed from a data provider). It does **not** load Google Maps live at run time. In our tests (October 2026), most active listings had been refreshed **within the previous 1–2 months**. Records for closed businesses can be a year or more old. Every record carries `lastUpdatedTime` and `dataAgeDays` so you can judge for yourself, and the **"Record refreshed in the last N days"** filter drops stale records.

Other things to know:

- **"First seen" is not an opening date.** It is when the provider's crawler first found the listing, and an established business can be "first seen" recently. To find likely *new* businesses, use the `soonToOpen` preset (first seen in the last 90 days, no reviews yet) or combine *first seen in the last 60–90 days* with *fewer than 5 reviews*. Google doesn't publish an exact opening date, so treat these as likely new or about to open.

- **Only new since last run:** turn on the monitor option and set a Monitor name (one name per town or saved search). The first run saves every matching `placeId` as a baseline and returns nothing (and is not charged). Later runs return only businesses not seen before, and you are charged only for those. Set `maxResults` high enough to cover the area so the baseline is complete. The state is stored in a named key-value store on your account (`maps-leads-monitor-…`) and IDs not seen for 180 days are dropped.

- **Coverage is good but not 100% of Google Maps.** Some businesses are missing, and a business can have a website that Google doesn't show. Check a lead on its Google Maps link before you pitch.

- **"close" status** means the business was outside its opening hours at crawl time. It does not mean the business is closed for good. Permanently closed businesses show `closed_forever`.

### Pricing

Pay per event. You pay only for businesses delivered, and businesses that match a premium segment filter (no website, unclaimed, rating below, fewer reviews, first seen) are priced as segment results. Runs that return no businesses, have invalid input or hit provider errors are **not charged**. The Actor respects your **maximum charge per run**: it requests only as many businesses as fit your budget.

| Event | Price | When it's charged |
|---|---|---|
| Run start | $0.015 per run | Once per run, only if at least one business is returned |
| Business | $0.002 per business ($2.00 per 1,000) | Each business delivered when no premium segment filter is used |
| Segment business | $0.005 per business ($5.00 per 1,000) | Each business delivered when a premium segment filter is used (no website, social-only, unclaimed, rating below, fewer reviews, first seen) |
| Actor start (Apify) | $0.00005 per run | Apify's standard start event (one per GB of memory; the default 256 MB is one event) |

Examples: 100 plumbers with no website cost $0.015 + 100 × $0.005 = **$0.515**. 1,000 dentists with no segment filter cost $0.015 + 1,000 × $0.002 = **$2.015**. Apify's $0.00005 start event comes on top. Filters such as category, location, business status, sorting or "updated within N days" don't make a run a segment run.

The default maximum charge per run is $3.00, about 10–20 typical runs. Raise it in the run options if you need a larger job.

### Run time and cost examples

Costs use the current list prices on the Apify Free plan, including Apify's $0.00005 start event. Run times are from our own test runs in October 2026 at the default memory; yours depend on the input.

| Run | Run time (our tests) | Cost (Free plan) |
|---|---|---|
| 20 plumbers in Austin, TX with no website and an unclaimed profile | about 4 s | about $0.115 |
| 100 plumbers with no website | not measured yet | about $0.52 |
| 1,000 dentists, no segment filter | not measured yet | about $2.02 |

Business: $0.002 on the Apify Free plan, $0.0018 on Starter (Bronze), $0.0016 on Scale (Silver), $0.0015 on Business (Gold) and above. The discount is applied automatically. Segment business: $0.005 / $0.0045 / $0.004 / $0.00375.

### Tips

- **Covering a big metro:** run a few coordinate circles of 10–25 km rather than one huge radius, then dedupe on `placeId`.
- **Finding category names:** use the Google Maps category in snake_case (`roofing_contractor`, `nail_salon`, `real_estate_agency`). A misspelling returns suggestions.
- **Scheduling:** run it weekly with *first seen in the last 7 days* to get a feed of newly listed businesses in your area.

### Use it from an AI agent (Apify MCP)

Give Claude, Cursor, VS Code or any other MCP client this Actor as a tool through the [Apify MCP server](https://mcp.apify.com). Add this to your client's MCP config; you sign in to Apify with OAuth on first connect:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=steady-scrape/google-maps-business-segments"
    }
  }
}
```

Clients without OAuth can send an `Authorization: Bearer <APIFY_TOKEN>` header instead. Then ask, for example: *"Find plumbers within 25 km of Austin, TX that have no website on their Google Maps profile."* The agent starts a normal run, so the prices above and your maximum charge per run still apply.

### FAQ

**Is this a Google Maps scraper?** No browser and no scraping at run time. It reads a licensed, regularly refreshed database of Google Maps listings, which is why runs are fast and never get blocked, and why records come with freshness dates.

**Why is my list shorter than Google Maps shows?** The filters are strict (for example, "no website" means no URL at all on the profile), and the database doesn't hold every listing. Use a larger radius or fewer filters.

**Can I get emails?** No, by design. This Actor gives business-level data only.

**Is it legal to use this data?** The data covers publicly listed businesses. You are responsible for following the marketing and privacy laws that apply to you (for example the GDPR, PECR, CASL, Quebec's Law 25, the TCPA and do-not-call rules) and for honouring opt-outs.

**How do I find local businesses without a website?** Pick a category and an area, set the website filter to *no website*, and run. You get only businesses whose Google Maps profile has no website, priced as segment results.

**How do I find businesses that are opening soon?** Use the `soonToOpen` preset. It returns listings first seen in the last 90 days that have no reviews yet, newest first, which is where soon-to-open and just-opened businesses show up. For a weekly feed of only listings that appeared since last time, turn on *Only new since last run* and give the search a Monitor name.

**Is there a preset for businesses with no website?** Yes: `leadPreset: noWebsite`. Add `claimStatus: unclaimed` to get the warmest web design leads.

**Can I find unclaimed Google Business Profiles?** Yes. Use the unclaimed filter; it's one of the premium segment filters.

**How much does a list of 100 leads cost?** About $0.52 for 100 businesses with a segment filter, or $0.22 without one.

### Ready-made examples and workflows

- [Dentists with a low rating and few reviews](https://apify.com/steady-scrape/google-maps-business-segments/examples/dentists-low-rating-few-reviews-leads): a saved lead search you can run as is, then change the category and city.
- [Likely new restaurants first seen in the last 60 days](https://apify.com/steady-scrape/google-maps-business-segments/examples/new-restaurants-opened-last-60-days): fresh listings for new-business outreach.
- [n8n template: local businesses without a website to Google Sheets](https://github.com/steadyscrape/steadyscrape-examples/blob/main/n8n/find-local-businesses-without-a-website-to-google-sheets.json): a form asks for category and city, and leads are added to your sheet without duplicates.

### More from SteadyScrape

- [Public Tenders Monitor](https://apify.com/steady-scrape/public-tenders-monitor): government tenders and contract opportunities from SAM.gov (US), CanadaBuys (Canada) and TED (EU) in one feed; scheduled runs return only new and amended notices.
- [Review Intelligence: Google, Trustpilot, Tripadvisor Reviews](https://apify.com/steady-scrape/review-intelligence): Google Maps, Trustpilot and Tripadvisor reviews without reviewer names, plus rating trends and AI complaint themes for the businesses you just found.
- [Google Shopping Offer Monitor](https://apify.com/steady-scrape/google-shopping-monitor): Google Shopping prices and sellers by keyword or GTIN; monitor mode returns only new or changed offers.
- [Company Data by Domain](https://apify.com/steady-scrape/company-profile-by-domain): name, logo, description, industry and social links for a list of domains, from each company's own site. Enrich the leads that do have a website.
- [Canada Building Permits: Toronto, Vancouver, Calgary, Montréal](https://apify.com/steady-scrape/canada-building-permits): issued building permits from four big Canadian cities, new permits show which contractors and projects are active in each city.
- [Find Websites Using Any Technology: Lead Lists](https://apify.com/steady-scrape/tech-stack-lead-lists): lists of company websites running a given tool (Shopify, HubSpot, Stripe and more), filtered by country and freshness. The B2B counterpart to local Maps leads.
- [Keyword Search Volume](https://apify.com/steady-scrape/keyword-search-volume): Google search volume, CPC, competition and a 12-month trend for up to 10,000 keywords per run. Size the local demand behind each lead's services.

See every **SteadyScrape (steady-scrape)** Actor on [our Apify profile](https://apify.com/steady-scrape).

### The Agency Lead Stack

Running lead gen for clients? These work as one workflow:

1. **Find the businesses** — Google Maps Leads pulls segmented local business lists ([apify.com/steady-scrape/google-maps-business-segments](https://apify.com/steady-scrape/google-maps-business-segments))
2. **See what they're running** — Google Ads Transparency shows every Google ad a prospect or competitor is live with ([apify.com/steady-scrape/google-ads-transparency](https://apify.com/steady-scrape/google-ads-transparency))
3. **Read their reviews** — Review Intelligence pulls Google, Trustpilot and Tripadvisor reviews without reviewer names, plus rating trends and AI complaint themes ([apify.com/steady-scrape/review-intelligence](https://apify.com/steady-scrape/review-intelligence))
4. **Keep watching** — pair them with the monitors above so new tenders, offers and creatives land as they change.

Questions or a filter you need? Open an issue on the Issues tab.

### Acceptable use

You may not use results from this service to build or operate a search engine, or any product or service that competes with or harms the business of search engine providers.

— SteadyScrape

# Actor input Schema

## `categories` (type: `array`):

1-10 Google Maps business categories, e.g. plumber, dentist, roofing_contractor, hair_salon, restaurant. Spaces are fine ('roofing contractor'). Common French names work too, e.g. toiture, couvreur, revêtement extérieur, coiffure, plombier, dentiste. Unknown names fail fast with suggestions. Businesses match on their main or additional categories.

## `cityPreset` (type: `string`):

Pick a Canadian city and the Actor fills in its centre coordinates and countryCode CA for you (replaces 'coordinates' and 'city'). Set 'Radius (km)' to cover the area you want; the suggested whole-city radius is shown next to each city.

## `coordinates` (type: `string`):

Search around a point, e.g. 30.2672,-97.7431. Most complete way to cover a metro area (catches suburbs that a city name misses). Use with radius.

## `radiusKm` (type: `integer`):

Radius around the coordinates, in kilometres.

## `city` (type: `string`):

Alternative to coordinates: exact city name as written in the business address, e.g. Austin (all-lowercase input is capitalised automatically). Add a country code to avoid same-name cities elsewhere.

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

2-letter ISO code, e.g. US, GB, CA, AU. Can be used alone for country-wide lists.

## `postalCode` (type: `string`):

Optional exact postal code, e.g. 78704.

## `leadPreset` (type: `string`):

Shortcut for the two most-asked lead lists. noWebsite = only businesses with no website on their Google profile. soonToOpen = listings first seen in the last 90 days with no reviews yet, newest first (likely new or about-to-open businesses; Google gives no exact opening date). Presets set the matching filters below; your own 'First seen' or 'Fewer reviews than' values still win. Both are segment lists (segment price).

## `website` (type: `string`):

Segment: businesses without a website on their Google profile (web design and local SEO leads).

## `claimStatus` (type: `string`):

Segment: unclaimed Google Business Profiles.

## `ratingBelow` (type: `string`):

Segment: only businesses with a star rating strictly below this value, e.g. 4 or 3.5 (reputation management leads). Unrated businesses are excluded unless you tick the next option.

## `includeUnrated` (type: `boolean`):

Also return businesses that have no rating at all.

## `ratingAtLeast` (type: `string`):

Optional lower bound for the rating, e.g. 2 (combine with 'Rating below' for a band). Not a segment filter.

## `reviewsBelow` (type: `integer`):

Segment: businesses with fewer than this many reviews (businesses with zero reviews are included), e.g. 10.

## `minReviews` (type: `integer`):

Optional lower bound for the review count. Not a segment filter.

## `firstSeenWithinDays` (type: `integer`):

Segment: listings the data provider's crawler first found in the last N days. This is NOT the business opening date: an old business can be 'first seen' recently. Combine with 'Fewer reviews than' 5 to find likely new businesses.

## `updatedWithinDays` (type: `integer`):

Freshness filter: only records the database refreshed in the last N days (e.g. 60). Not a segment filter.

## `businessStatus` (type: `string`):

Status from the Google profile. Not a segment filter.

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

Maximum number of businesses to return (up to 10,000 per run). You are charged only for businesses returned.

## `sortBy` (type: `string`):

Which matching businesses come first when there are more than 'Max businesses'.

## `dropPhones` (type: `boolean`):

Remove the business phone from every record. Recommended if you will contact EU/UK/Quebec sole traders or don't need phones. Phone-like numbers in the business description are masked too.

## `includeHours` (type: `boolean`):

Weekly opening hours per business.

## `includeAttributes` (type: `boolean`):

Google attributes (e.g. has_delivery, wheelchair access), review topic keywords and booking/order links.

## `onlyNewSinceLastRun` (type: `boolean`):

Return only businesses not seen in a previous run that used the same Monitor name. The first run saves a baseline and returns nothing (and is not charged), unless you tick 'On the first run, return the current matches'. Uses a named key-value store on your account. Existing one-off lists are unchanged if this is off. Set maxResults high enough to cover the whole area so the baseline is complete.

## `monitorName` (type: `string`):

Required when 'Only new since last run' is on. A short name for this saved search, e.g. tamarindo-soon or austin-restaurants. Each town or schedule should use its own name. Letters, numbers, '\_' and '-' only.

## `firstRunEmitsAll` (type: `boolean`):

If on, the first monitor run returns every current match (and is charged for them) and still saves the baseline. If off, the first run saves the baseline and returns nothing.

## Actor input object example

```json
{
  "categories": [
    "plumber"
  ],
  "cityPreset": "none",
  "coordinates": "30.2672,-97.7431",
  "radiusKm": 15,
  "leadPreset": "none",
  "website": "noWebsite",
  "claimStatus": "any",
  "includeUnrated": false,
  "businessStatus": "operating",
  "maxResults": 50,
  "sortBy": "reviewsDesc",
  "dropPhones": false,
  "includeHours": true,
  "includeAttributes": true,
  "onlyNewSinceLastRun": false,
  "firstRunEmitsAll": false
}
```

# Actor output Schema

## `overview` (type: `string`):

One row per business.

## `freshness` (type: `string`):

When each record was last refreshed and first seen.

## `summary` (type: `string`):

Totals, filters used and charges.

# 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 = {
    "categories": [
        "plumber"
    ],
    "coordinates": "30.2672,-97.7431",
    "radiusKm": 15,
    "website": "noWebsite",
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("steady-scrape/google-maps-business-segments").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 = {
    "categories": ["plumber"],
    "coordinates": "30.2672,-97.7431",
    "radiusKm": 15,
    "website": "noWebsite",
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("steady-scrape/google-maps-business-segments").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 '{
  "categories": [
    "plumber"
  ],
  "coordinates": "30.2672,-97.7431",
  "radiusKm": 15,
  "website": "noWebsite",
  "maxResults": 50
}' |
apify call steady-scrape/google-maps-business-segments --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,steady-scrape/google-maps-business-segments"
        }
    }
}
```

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/2bghNMoi2bwynQhGu/builds/NroVrPfShlkuKkYGG/openapi.json