Google Maps Extractor with Ownership & Accessibility Attributes

Google Maps Scraper — Extract Places, Ownership & Accessibility Data

This Actor scrapes business places from Google Maps by keyword and location, then adds two data families most Google Maps scrapers skip: self-declared ownership badges (women-owned, Black-owned, Latino-owned, Asian-owned, Indigenous-owned, veteran-owned, LGBTQ+ owned, LGBTQ+ friendly) and published accessibility attributes (wheelchair entrance, restroom, seating, parking, assistive hearing loop). Every response returns typed, normalized JSON — no HTML, no selectors, no parsing. Tick the badges or accessibility features you need and the run returns a pre-filtered shortlist instead of a raw dump. Read on for every field, and every real limit.

---

🗺️ What is Google Maps Extractor with Ownership & Accessibility Attributes?

It's a Google Maps places scraper that reads two extra attribute families — ownership/identity badges and accessibility attributes — out of the same Google response it already fetches for the name and address, then lets you filter the sweep down to only places that carry the ones you need. No Google account, API key or billing is required: it calls Google's own public map-search endpoint directly, the same one your browser loads when you search Google Maps while logged out.

• Scrape places by business-type keyword, by area, or from a pasted Google Maps link
• Read Google's self-published ownership/identity badges off every place, no extra request
• Read Google's published accessibility attributes off every place, no extra request
• Filter the whole sweep to only qualifying places with requiredOwnershipBadges / requiredAccessibilityFeatures
• Export as JSON, or any format Apify's dataset view supports (CSV, Excel, and more)

---

📊 What data does Google Maps Extractor with Ownership & Accessibility Attributes collect?

Every run returns one JSON record per place, built from three data families that live inside the same Google Maps response — the standard place record, its ownership/identity badges, and its accessibility attributes.

Data Type	Key Fields	JSON Field Names
Places	Name, Google's own formatted address, phone, website, rating, category tags, coordinates, today's opening hours	name, full_address, phone, website, avg_rating, tags, lat, long, hours
Ownership badges	Self-declared identity badges plus 8 per-badge true/false fields	ownership_badges, is_women_owned, is_black_owned, is_latino_owned, is_asian_owned, is_indigenous_owned, is_veteran_owned, is_lgbtq_owned, is_lgbtq_friendly, is_diversity_owned
Accessibility attributes	Published physical-access features plus 5 per-feature true/false fields	accessibility_features, accessibility_feature_keys, wheelchair_accessible_entrance, wheelchair_accessible_restroom, wheelchair_accessible_seating, wheelchair_accessible_parking, assistive_hearing_loop

---

🔌 How does this Actor differ from the official Google Places API?

Google's own Places API (New) returns place data too, but ownership and accessibility coverage — and the setup — work differently.

Feature	Google Places API (New)	This Actor
Access requirement	Google Cloud project, enabled billing and an API key on every request	An Apify account — no separate Google signup
Ownership / identity badges	Not present in the published Place Data Fields list	Returned as ownership_badges plus 8 boolean fields
Accessibility attributes	Available via accessibilityOptions, gated behind the paid Text Search Pro SKU	Included on every row, no field mask to configure
Default response fields	None — a field mask is mandatory or the call errors	Every documented field below is returned on every row
Pricing model	Per-field SKU tiers — e.g. Text Search Pro bills at $32.00 per 1,000 calls in the first 100,000 calls/month	Apify pay-per-result — one row_result event per saved place
Area sweep by city/region name	Not built in — you geocode and page requests yourself	Built in: a location name resolves to a bounding box and is swept tile by tile
Supplier / accessibility pre-filtering	Not available — filter the raw response yourself	requiredOwnershipBadges / requiredAccessibilityFeatures filter the run itself

(Google's field list, field-mask requirement and SKU pricing checked on developers.google.com/maps/documentation/places and developers.google.com/maps/billing-and-pricing/sku-details, 2026-08-04.)

The official API is the right call if you're already inside the Google Cloud billing ecosystem and only need a handful of fields per place. This Actor is faster when you want a ready-made area sweep with ownership and accessibility data already attached and pre-filterable, without building field-mask logic or a geocoder yourself.

---

🎯 Why do developers and teams scrape Google Maps for this data?

🏢 For supplier-diversity and procurement teams

Corporate Tier-2 supplier-diversity programs and public-sector procurement teams need a shortlist of women-, Black-, Latino-, Asian-, Indigenous- or veteran-owned vendors in a metro area — not a manual search through hundreds of listings. Set keywords to the trade you need (general contractors, print shop, staffing agency), set locations to the metro, tick the relevant boxes in requiredOwnershipBadges, and the run returns only places carrying them, with ownership_badges, is_diversity_owned and each individual boolean ready to drop into a spend-tracking spreadsheet or supplier database.

♿ For accessibility auditors and inclusive-venue directories

ADA compliance auditors, disability-inclusion consultants and accessible-travel apps need per-venue accessibility data, not the Maps app's own rendering of it. Set requiredAccessibilityFeatures to the attributes that matter — wheelchair entrance, restroom, seating, parking, or an assistive hearing loop — and badgeMatchMode to all for a strict, fully-accessible shortlist or any for a wider one. Every saved row carries accessibility_features, accessibility_feature_keys (Google's stable, language-independent identifiers) and five boolean columns, turning a district-wide sweep into a ready-made accessible-venue list.

🤖 For AI engineers and agent builders

An agent that answers "find me a wheelchair-accessible, women-owned coffee shop in Austin" needs structured facts, not a scraped page to summarize. Every row is typed JSON — name, full_address, wheelchair_accessible_entrance, is_women_owned and the rest — ready to index into a vector store, drop into an LLM's context window, or call as a tool inside an agent loop, with zero HTML parsing between Google's response and the model.

🔬 For researchers and DEI reporting teams

Academic researchers studying the geography of business ownership, and internal DEI or ESG reporting teams building an evidence base for community-investment claims, both need publicly available counts, not a private data source. Sweep a city, county or state by business category, and ownership_badge_count, accessibility_feature_count and the per-badge booleans turn a raw place list into a source-cited count of how many listed businesses in the area publish which attributes.

---

🛠️ How to scrape Google Maps for ownership and accessibility data (step by step)

1. Open this Actor's page on the Apify Store or in your own Apify Console.
2. Provide the required input: at least one entry in keywords — the business types to search for.
3. Set locations (cities, counties, states, or countries) and/or paste urls; optionally tick requiredOwnershipBadges and/or requiredAccessibilityFeatures and set badgeMatchMode to turn the sweep into a filtered shortlist.
4. Start the run. Apify Proxy is enabled by default, and the Actor steps up to a residential proxy on its own if Google starts refusing the current exit.
5. Download the results from the run's dataset — JSON by default, or any export format the Apify dataset view supports (CSV, Excel, and more).

What to do when Google Maps changes its structure

Google's map-search response is unofficial and can change without notice — this Actor's parser reads specific numbered offsets out of that response (place[196] for badges, place[100] for accessibility), and it is maintained against drift. Field names and types stay the same on your end even when the underlying parsing has to change. No fixed turnaround time is promised for any given breakage.

---

⬇️ Input

Eight parameters, one required. Read directly from .actor/actor.json.

Parameter	Required	Type	Description	Example Value
keywords	Yes	array of strings	Business types to look for — for example coffee shops, general contractors, dentists, staffing agency, print shop. Default: ["coffee shops"]	["coffee shops"]
locations	No	array of strings	City, borough, county, state or country names. Each one is resolved to a real bounding box (via OpenStreetMap) and swept cell by cell; every result is checked against that box before it's saved. Default: ["New York"]	["New York"]
urls	No	array of strings	Or paste Google Maps links instead. Supports /maps/search/<terms>/@lat,lng,zoom and /maps/place/<Name>/@lat,lng,zoom. Links that identify a place only by place_id/ftid/cid are not supported. Default: []	["https://www.google.com/maps/search/coffee+shops/@40.7128,-74.0060,13z"]
requiredOwnershipBadges	No	array (select; enum)	Only keep places carrying these self-identification badges. Enum: women_owned, black_owned, latino_owned, asian_owned, indigenous_owned, veteran_owned, lgbtq_owned, lgbtq_friendly. Empty = no ownership requirement. Default: []	["women_owned", "veteran_owned"]
requiredAccessibilityFeatures	No	array (select; enum)	Only keep places offering these accessibility features. Enum: wheelchair_entrance, wheelchair_restroom, wheelchair_seating, wheelchair_parking, hearing_loop. Empty = no accessibility requirement. Default: []	["wheelchair_entrance"]
badgeMatchMode	No	string (select; enum)	How strictly to apply the ticks above. any = at least one ticked item (wider list); all = every ticked item (strict shortlist). Ignored while both boxes above are empty. Default: "any"	"all"
maxResults	No	integer (1–10000)	Total unique qualifying places to save, across all business types, areas and links. Default: 50	200
proxyConfiguration	No	object (proxy editor)	Your proxy groups and country, passed through unchanged. Default: {"useApifyProxy": true}	{"useApifyProxy": true}

Leaving both requiredOwnershipBadges and requiredAccessibilityFeatures empty returns every place in the area, with the badge and accessibility columns still filled in — use it as a plain extractor with two extra data families.

Common pitfall: providing keywords but leaving both locations and urls empty. The run fails immediately with "Nothing to search in" — a keyword needs an area, or a Maps link carrying its own coordinates, to search within.

Example input

{
  "keywords": ["general contractors", "print shop"],
  "locations": ["Austin, Texas"],
  "urls": [],
  "requiredOwnershipBadges": ["women_owned", "veteran_owned"],
  "requiredAccessibilityFeatures": ["wheelchair_entrance"],
  "badgeMatchMode": "all",
  "maxResults": 200,
  "proxyConfiguration": { "useApifyProxy": true }
}

---

⬆️ Output

One typed JSON row per unique place, deduplicated on Google's own place_id. Every pushed row is a row_result charged event — rows dropped by de-duplication, the area-boundary check, or the ownership/accessibility filters are never pushed, so you are only ever billed for a place that actually ends up in your dataset.

Scraped place record

Standard place fields

Field	Type	Description
rowType	string	Row type discriminator, always "place"
name	string / null	Business name
street_address	string / null	Street portion of the address
city	string / null	City
state	string / null	State / region
zip	string / null	Postal code
country_code	string / null	Country code as Google returns it
full_address	string / null	Google's own one-line formatted address (not a concatenation of the parts)
phone	string / null	Phone number as published
website	string / null	Website URL
avg_rating	number / null	Average rating, 0–5
tags	array of strings / null	Category tags
place_id	string / null	Google's place ID — used for de-duplication
lat	number / null	Latitude
long	number / null	Longitude
hours	array of objects	Today's opening hours only — Google's map-search response carries one weekday, not the week. Each entry: day, hours (Google's own text), opens_at, closes_at ("HH:MM")

Ownership & identity

Field	Type	Description
ownership_badges	array of strings	Badge labels exactly as Google publishes them, e.g. ["LGBTQ+ friendly", "Identifies as women-owned"]
ownership_badge_count	integer	Length of the array above
is_women_owned, is_black_owned, is_latino_owned, is_asian_owned, is_indigenous_owned, is_veteran_owned, is_lgbtq_owned, is_lgbtq_friendly	boolean	Never null — ⚠️ false means "not published," not "no." Ownership badges are voluntary self-identification
is_diversity_owned	boolean	True when any ownership badge is present; is_lgbtq_friendly is excluded since it's a welcome statement, not an ownership claim
hotel_checkin_time	string / null	Lodging listings publish a check-in time inside this same badge block, so it's split out here; null on every non-lodging place

Accessibility

Field	Type	Description
accessibility_features	array of strings	Attribute labels as Google publishes them, e.g. ["Wheelchair accessible entrance", "Wheelchair accessible restroom"]
accessibility_feature_keys	array of strings	Google's language-independent attribute keys, e.g. /geo/type/establishment_poi/has_wheelchair_accessible_entrance — stable across languages
accessibility_feature_count	integer	Length of accessibility_features
wheelchair_accessible_entrance, wheelchair_accessible_restroom, wheelchair_accessible_seating, wheelchair_accessible_parking, assistive_hearing_loop	boolean	Never null. Only Google's accessibility attribute group is read — the other groups it publishes (amenities, parking, service_options, crowd, planning, payments, offerings, from_the_business) are real but far sparser and are a different product

Example row

{
  "rowType": "place",
  "name": "Coffee Project New York | East Village",
  "street_address": "239 E 5th St",
  "city": "New York",
  "state": "New York",
  "zip": "10003",
  "country_code": "US",
  "full_address": "239 E 5th St, New York, NY 10003",
  "phone": "(212) 228-7888",
  "website": "https://coffeeprojectny.com/",
  "avg_rating": 4.6,
  "tags": ["Coffee shop", "Breakfast restaurant", "Cafe"],
  "place_id": "ChIJ_dckWptZwokR_LkU9WxPNZ4",
  "lat": 40.7270884,
  "long": -73.9893819,
  "hours": [
    { "day": "Sunday", "hours": "8 AM-5:30 PM", "opens_at": "08:00", "closes_at": "17:30" }
  ],
  "ownership_badges": [
    "LGBTQ+ friendly",
    "Identifies as women-owned",
    "Identifies as Asian-owned",
    "Identifies as LGBTQ+ owned"
  ],
  "ownership_badge_count": 4,
  "is_women_owned": true,
  "is_black_owned": false,
  "is_latino_owned": false,
  "is_asian_owned": true,
  "is_indigenous_owned": false,
  "is_veteran_owned": false,
  "is_lgbtq_owned": true,
  "is_lgbtq_friendly": true,
  "is_diversity_owned": true,
  "hotel_checkin_time": null,
  "accessibility_features": [
    "Wheelchair accessible entrance",
    "Wheelchair accessible seating",
    "Wheelchair accessible parking lot"
  ],
  "accessibility_feature_keys": [
    "/geo/type/establishment_poi/has_wheelchair_accessible_entrance",
    "/geo/type/establishment_poi/has_wheelchair_accessible_seating",
    "/geo/type/establishment_poi/has_wheelchair_accessible_parking"
  ],
  "accessibility_feature_count": 3,
  "wheelchair_accessible_entrance": true,
  "wheelchair_accessible_restroom": false,
  "wheelchair_accessible_seating": true,
  "wheelchair_accessible_parking": true,
  "assistive_hearing_loop": false
}

Four dataset views ship with this Actor: Places + ownership & accessibility (default), Ownership badges, Accessibility audit, and Opening hours (today only).

---

🔍 How does this Actor compare to other Google Maps scrapers?

Feature	This Actor	Generic Google Maps scraper
Ownership / identity badges	✅ 8 boolean fields plus the raw label list	❌ Not documented on typical listing-only scrapers
Accessibility attributes	✅ 5 boolean fields plus raw labels and Google's stable attribute keys	❌ Not typically extracted
Supplier / accessibility pre-filtering	✅ requiredOwnershipBadges / requiredAccessibilityFeatures filter the run itself	❌ Usually keyword/location filtering only
Output format	✅ Typed, normalized JSON on every run	⚠️ Varies by vendor
Schema stability	✅ Same field names whether or not filters are active	⚠️ Varies by vendor

If you're building an AI agent or RAG pipeline, the output-format row is the decision-maker — parsing HTML inside an agent loop is a reliability failure mode, not a feature.

---

📈 How many results can you scrape with this Actor?

maxResults caps a run at 10,000 saved places — the schema's maximum and the code's MAX_RESULTS_CAP agree on that number; there is no way to request more in a single run. maxResults counts saved, qualifying, deduplicated places, not raw candidates, so turning on a badge or accessibility filter means the sweep keeps expanding until it finds enough qualifying places or the searched area runs out.

Pagination works per grid tile: each location is geocoded into a bounding box, split into up to 400 tiles, and each tile is paged up to 3 times at up to 300 results per page — Google's map-search endpoint measurably returns nothing on a 4th page and caps out around 300 per page, so those are the surface's own limits, not an arbitrary choice. For very large regions, tile size grows automatically to stay within the 400-tile cap, which lowers sweep resolution for whole-country runs. A single tile intentionally keeps only a capped share of its own results, so one dense neighbourhood can't fill your entire maxResults budget on its own.

No throughput benchmark is published — actual place counts per run depend on the query, the area size, and how densely Google has indexed that area.

---

🔗 Integrate this Actor and automate your workflow

This Actor works with any language or tool that can send an HTTP request — it runs on Apify, so every run is reachable through the Apify API.

REST API integration

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_API_TOKEN>")

run = client.actor("<username>/google-maps-extractor-with-ownership-accessibility-attributes").call(
    run_input={
        "keywords": ["coffee shops"],
        "locations": ["New York"],
        "requiredAccessibilityFeatures": ["wheelchair_entrance"],
        "maxResults": 100,
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["wheelchair_accessible_entrance"])

Works in Python, Node.js, Go, Ruby, cURL — any client that can call the Apify API.

Scheduling and webhooks

Use an Apify schedule in the Console to re-run a sweep on a recurring basis, or attach a webhook to fire when a run finishes so a downstream workflow picks up the new rows automatically.

---

⚖️ Is it legal to scrape Google Maps?

Yes. This Actor only reads what Google already serves on its public, logged-out Google Maps search page — the same place names, addresses, ratings, ownership badges and accessibility attributes any visitor sees without signing in. No login, paywall or private dataset is accessed.

The data returned describes businesses and their self-published attributes, not identified private individuals, so this falls under Google's own Terms of Service and under database-rights law where it applies — not GDPR or CCPA, which govern personal data about natural persons. Ownership badges are a business's own voluntary declaration on its Google Business Profile, not personal data pulled from a private source.

Scraping public data is broadly permitted in most jurisdictions, but reuse remains bound by Google's Terms of Service. Consult legal counsel for commercial use cases involving bulk data collection.

---

❓ Frequently asked questions

Does this Actor work without a Google account?

Yes. It calls Google's public map-search endpoint directly with a browser-style request; no Google account, API key or billing is required. An Apify account is required to run the Actor itself.

How often is the scraped data updated?

Every run fetches live from Google's map-search endpoint — there is no cache. Two runs minutes apart on the same query can return different results if Google's own index changed in between.

What happens when a place has no coordinates or can't be matched to the requested area?

It's dropped before it's saved and never charged. Places without a resolvable place_id, without coordinates, or outside the geocoded bounding box for the requested location are counted internally and skipped — they never reach the dataset.

Can I scrape private or login-gated Google Maps content?

No. Only what Google serves on its public, logged-out map-search surface is returned. Links that identify a place solely by place_id, ftid or cid aren't supported either — that lookup path doesn't exist on this response surface, so the run logs and skips them rather than guessing.

Is there a limit on how many keywords or locations I can combine in one run?

No schema limit on the size of the keywords or locations arrays themselves. Every keyword is searched in every location (3 keywords × 2 locations = 6 sweeps), and the maxResults budget is split evenly across all of them plus any urls.

Does this Actor work for AI agent workflows and LLM pipelines?

Yes. It's callable as an HTTP endpoint via the Apify API from any agent framework. Every response is typed JSON — no parsing step is needed before passing a row to an LLM.

How does this Actor handle Google Maps' anti-bot system?

With retries and proxy escalation, not evasion tricks. Each request retries up to 3 times; a blocked or unreadable response (HTTP 403/429/503, or a payload Google's anti-hijacking envelope won't decode) escalates the connection to the next proxy tier, moving from datacenter to residential after repeated failures on the same tier.

How does this Actor compare to other Google Maps scrapers?

The main observable difference is scope: this Actor extracts ownership/identity badges and accessibility attributes as structured, filterable fields on every row, which listing-only Google Maps scrapers typically don't document. See the comparison table above for the specific fields.

Does this Actor return data in a format LLMs can use directly?

Yes. Typed, normalized JSON with stable field names — no HTML, no selectors. Pass a row directly into an LLM's context window, index it into a vector store, or route it through an agent tool.

Can I use this Actor without managing proxies?

Yes. Apify Proxy is on by default, and a datacenter exit is normally enough — Google's map endpoint honors the coordinates this Actor sends regardless of where the exit is located. If Google starts refusing the current exit mid-run, the Actor steps up to residential on its own.

What happens when Google changes its Maps structure or blocks the scraper?

This Actor is maintained, and the output schema stays stable — field names and types don't change on your end even when the internal parsing has to be updated to follow a change on Google's side. No numeric turnaround time is promised for any specific breakage.

---

💬 Your feedback

Found a bug, or missing a field you need? We want to know. Use the Issues tab on this Actor's Apify Console page, or reach out through Apify's normal support channel — active maintenance is how this Actor's output schema stays stable for you.