# Bing Maps Places Scraper (`automation-lab/bing-maps-places-scraper`) Actor

Extract local business leads from Bing Maps searches: names, categories, addresses, phones, websites, ratings, reviews, and coordinates.

- **URL**: https://apify.com/automation-lab/bing-maps-places-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Bing Maps Places Scraper

### What does Bing Maps Places Scraper do?

Bing Maps Places Scraper extracts local business listings from Bing Maps search results. It is designed for lead generation, local SEO research, market mapping, and sales operations teams that need an alternative or complement to Google Maps data. The actor uses Bing Maps search pages and saves clean rows with business names, categories, addresses, phone numbers, websites, ratings, review counts, coordinates, and source links.

### Who is it for?

• Sales teams building local prospect lists.

• Agencies comparing local visibility across markets.

• SEO consultants checking business categories and map presence.

• Data teams enriching CRM records with public local-business data.

• Founders validating city-by-city market coverage.

### Why use it?

Bing Maps is a useful secondary local-business source. Many teams rely only on Google Maps; adding Bing Maps can reveal additional websites, phone numbers, and listings. The actor outputs structured JSON/CSV/Excel-ready rows so you can move straight into filtering, deduplication, and outreach workflows.

### How it works

Enter one or more searches such as `coffee Seattle`, `dentists Austin TX`, or `plumbers Manchester UK`. The actor calls Bing Maps local result overlays, parses the embedded place payloads, removes duplicates, and pushes each place to the default Apify dataset.

### Input overview

The primary input is `searchQueries`. You can also paste Bing Maps URLs in `startUrls`; the actor extracts the query from the URL. Use `maxResults` to control cost and run length. Use the `market` field when scraping outside the United States.

### Output data table

Each dataset row represents one Bing Maps place. Common fields include `placeName`, `category`, `address`, `phone`, `website`, `rating`, `reviewCount`, `latitude`, `longitude`, `bingMapsUrl`, `placeId`, and `searchQuery`.

### How much does it cost to scrape Bing Maps places?

The actor uses pay-per-event pricing: a small start fee and a per-place result fee. Keep first runs small, for example 30 places, then scale after checking output quality for your target market.

### Example searches

Try searches that combine a business type with a location: `coffee Seattle`, `roofers Phoenix AZ`, `law firms Toronto`, `gyms Berlin`, or `restaurants near Pike Place Market`. Specific searches usually produce cleaner leads than broad single-word categories.

### Step-by-step guide

1. Open the actor on Apify.

2. Add one or more search queries.

3. Set `maxResults` to a small test value.

4. Run the actor.

5. Export the dataset as CSV, JSON, Excel, or via API.

6. Deduplicate against your CRM or outreach list.

### Tips for better results

Use city and region names to disambiguate locations. Run separate searches for related categories. For example, a home-services campaign might run `plumbers Denver`, `emergency plumbers Denver`, and `drain cleaning Denver` separately.

### Integrations

Use Apify integrations to send Bing Maps leads to Google Sheets, Make, Zapier, webhooks, or your data warehouse. A common workflow is: run scheduled searches weekly, export new websites and phone numbers, enrich them in a CRM, and route high-value leads to a sales queue.

### API usage

You can run the actor through the Apify API from Node.js, Python, cURL, Make, Zapier, or any HTTP client. Use actor ID `automation-lab/bing-maps-places-scraper` in API calls after publication.

### Node.js example

```js

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor("automation-lab/bing-maps-places-scraper").call({

  searchQueries: ["coffee Seattle"],

  maxResults: 30

});

console.log(run.defaultDatasetId);

````

### Python example

```python

from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")

run = client.actor("automation-lab/bing-maps-places-scraper").call(run_input={

    "searchQueries": ["dentists Austin TX"],

    "maxResults": 30,

})

print(run["defaultDatasetId"])

```

### cURL example

```bash

curl -X POST "https://api.apify.com/v2/acts/automation-lab~bing-maps-places-scraper/runs?token=$APIFY_TOKEN" \

  -H "Content-Type: application/json" \

  -d '{"searchQueries":["coffee Seattle"],"maxResults":30}'

```

### MCP usage

Use the Apify MCP server with Claude Desktop, Claude Code, or another MCP-compatible assistant. Configure the MCP endpoint with `?tools=automation-lab/bing-maps-places-scraper` so the assistant exposes only this actor tool when you are building local lead lists.

Claude Code setup example:

```bash
claude mcp add apify-bing-maps "https://mcp.apify.com/?tools=automation-lab/bing-maps-places-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-bing-maps": {
      "url": "https://mcp.apify.com/?tools=automation-lab/bing-maps-places-scraper"
    }
  }
}
```

Example prompts you can ask after connecting MCP:

- “Run Bing Maps Places Scraper for 25 dentists in Austin and give me a CSV-ready summary.”
- “Find coffee shops in Seattle from Bing Maps and highlight listings without websites.”
- “Compare plumbers in Phoenix by rating, phone availability, and website coverage.”

### Data quality notes

Bing decides which public fields are shown for each listing. Some places have websites and phones, while others only expose address and category. Ratings, review counts, and open status are optional fields and may vary by market.

### Limitations

The actor scrapes public Bing Maps search results. It does not log in, bypass private data, or guarantee that every local business has a phone or website. Bing may vary results by market, language, location, and time.

### Legality and compliance

This actor is intended for public business data. Use it responsibly, respect applicable laws, and follow outreach rules in your jurisdiction. Do not use scraped contact details for spam or unlawful profiling.

### Troubleshooting

If you get fewer results than expected, try a more specific query or a different market code. If Bing rate-limits large jobs, enable Apify Proxy or split searches into smaller runs.

### FAQ

**Can I scrape multiple cities?** Yes, add multiple queries such as `coffee Seattle`, `coffee Portland`, and `coffee Vancouver`.

**Does it return emails?** No. Bing Maps usually exposes phone and website fields, not email addresses. Use website enrichment separately if needed.

**Can I schedule it?** Yes. Use Apify schedules for weekly or monthly market monitoring.

### Related scrapers

Explore other local lead-generation actors from automation-lab on Apify, including Google Maps-style scrapers, directory scrapers, contact detail tools, and website enrichment actors.

### Support

If a target query stops returning expected results, open an Apify issue with the run URL, input, and a short description of the missing data. Include a small reproducible example so the developer can verify it quickly.

### Field reference

- `searchQuery` — public Bing Maps place field when available.

- `sourceUrl` — public Bing Maps place field when available.

- `placeName` — public Bing Maps place field when available.

- `category` — public Bing Maps place field when available.

- `address` — public Bing Maps place field when available.

- `locality` — public Bing Maps place field when available.

- `region` — public Bing Maps place field when available.

- `postalCode` — public Bing Maps place field when available.

- `country` — public Bing Maps place field when available.

- `phone` — public Bing Maps place field when available.

- `website` — public Bing Maps place field when available.

- `rating` — public Bing Maps place field when available.

- `reviewCount` — public Bing Maps place field when available.

- `latitude` — public Bing Maps place field when available.

- `longitude` — public Bing Maps place field when available.

- `bingMapsUrl` — public Bing Maps place field when available.

- `imageUrl` — public Bing Maps place field when available.

- `placeId` — public Bing Maps place field when available.

- `isOpen` — public Bing Maps place field when available.

### Changelog

- Initial version: Bing Maps place search extraction with HTTP overlay parsing.

# Actor input Schema

## `searchQueries` (type: `array`):

Business/category + location searches to run on Bing Maps, e.g. coffee Seattle or dentists Austin TX.

## `startUrls` (type: `array`):

Optional Bing Maps search URLs. The actor extracts the q= query and runs it through the same scraper.

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

Maximum number of Bing Maps places to save across all searches.

## `market` (type: `string`):

Bing market/language code. Use en-US for US searches, en-GB for UK searches, etc.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Leave disabled unless Bing rate-limits your workload.

## Actor input object example

```json
{
  "searchQueries": [
    "coffee Seattle",
    "dentists Austin TX"
  ],
  "startUrls": [
    {
      "url": "https://www.bing.com/maps?q=coffee%20Seattle"
    }
  ],
  "maxResults": 20,
  "market": "en-US",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchQueries": [
        "coffee Seattle",
        "dentists Austin TX"
    ],
    "startUrls": [
        {
            "url": "https://www.bing.com/maps?q=coffee%20Seattle"
        }
    ],
    "maxResults": 20,
    "market": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bing-maps-places-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 = {
    "searchQueries": [
        "coffee Seattle",
        "dentists Austin TX",
    ],
    "startUrls": [{ "url": "https://www.bing.com/maps?q=coffee%20Seattle" }],
    "maxResults": 20,
    "market": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bing-maps-places-scraper").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 '{
  "searchQueries": [
    "coffee Seattle",
    "dentists Austin TX"
  ],
  "startUrls": [
    {
      "url": "https://www.bing.com/maps?q=coffee%20Seattle"
    }
  ],
  "maxResults": 20,
  "market": "en-US"
}' |
apify call automation-lab/bing-maps-places-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/bing-maps-places-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bing Maps Places Scraper",
        "description": "Extract local business leads from Bing Maps searches: names, categories, addresses, phones, websites, ratings, reviews, and coordinates.",
        "version": "0.1",
        "x-build-id": "xOX5lLoqxORtL9dNh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bing-maps-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bing-maps-places-scraper",
                "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/automation-lab~bing-maps-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bing-maps-places-scraper",
                "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/automation-lab~bing-maps-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bing-maps-places-scraper",
                "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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Business/category + location searches to run on Bing Maps, e.g. coffee Seattle or dentists Austin TX.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Bing Maps URLs (optional)",
                        "type": "array",
                        "description": "Optional Bing Maps search URLs. The actor extracts the q= query and runs it through the same scraper.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Maximum places",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Bing Maps places to save across all searches.",
                        "default": 50
                    },
                    "market": {
                        "title": "Bing market",
                        "type": "string",
                        "description": "Bing market/language code. Use en-US for US searches, en-GB for UK searches, etc.",
                        "default": "en-US"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave disabled unless Bing rate-limits your workload.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
