# DuckDuckGo Local Places Scraper (`automation-lab/duckduckgo-local-places-scraper`) Actor

Extract DuckDuckGo local business results with names, addresses, phones, websites, ratings, coordinates, provider links, and query ranks.

- **URL**: https://apify.com/automation-lab/duckduckgo-local-places-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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

## DuckDuckGo Local Places Scraper

Scrape DuckDuckGo local places results for business names, categories, addresses, phones, websites, ratings, coordinates, and search metadata.

### What does DuckDuckGo Local Places Scraper do?

DuckDuckGo Local Places Scraper turns DuckDuckGo local search pages into a clean dataset of business/place records.

It accepts search phrases such as `dentists near Austin`, `coffee shops near Seattle`, or `plumbers in London`.

For every returned local place, it saves contact and location details that are useful for lead generation, local SEO, market research, and enrichment workflows.

### Who is it for?

- 🧭 Local lead generation agencies building prospect lists.
- 📍 SEO teams comparing local visibility across cities.
- 🧪 Market researchers checking business density by category.
- 🧰 Sales teams looking for websites, phones, and addresses.
- 🏢 Operations teams validating local branch data.

### Why use this actor?

DuckDuckGo aggregates local data from public providers and exposes useful business facts without requiring a user login.

This actor focuses on the local places vertical instead of general web results.

It is a lightweight HTTP actor, so runs are fast and inexpensive compared with browser-based scraping.

### What data can you extract?

| Field | Description |
| --- | --- |
| query | Search phrase used for the result |
| rank | Result position for that query |
| name | Business or place name |
| category | DuckDuckGo category when available |
| address | Full address |
| phone | Normalized phone number |
| displayPhone | Human-readable phone |
| website | Business website |
| sourceUrl | Provider listing URL, often Yelp |
| rating | Rating value |
| reviewCount | Review count |
| latitude / longitude | Coordinates |
| hours | Opening-hours object |
| imageUrl | Place image URL |
| sourceEngine | Source shown by DuckDuckGo |
| scrapedAt | Timestamp |

### How much does it cost to scrape DuckDuckGo local places?

The actor uses pay-per-event pricing: a small start charge per run plus a per-place charge for each saved result.

| Charge | Free tier | Bronze | Silver | Gold | Platinum | Diamond |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Saved place | $0.000207 | $0.000180 | $0.0001404 | $0.000108 | $0.000072 | $0.0000504 |

Example costs on the Free tier:

- 20 saved places: about $0.0091 (`$0.005` start + 20 × `$0.000207`).
- 50 saved places: about $0.0154.
- 100 saved places: about $0.0257.

For the first test run, keep the default two queries and 20 places per query. You only pay per saved result, so a query with fewer available DuckDuckGo local places costs less.

### Input

The main input is `queries`.

Use natural DuckDuckGo local phrases.

Good examples:

- `dentists near Austin`
- `coffee shops near Seattle`
- `roofers in Phoenix`
- `vegan restaurants in Berlin`
- `hotels near Prague old town`

### Input options

| Option | Type | Default | Notes |
| --- | --- | --- | --- |
| queries | array | required | Local search phrases |
| maxResultsPerQuery | integer | 20 | DuckDuckGo commonly returns about 20 places |
| region | string | us-en | DuckDuckGo locale hint |
| requestDelayMs | integer | 750 | Polite delay between queries |

### Output example

```json
{
  "query": "dentists near Austin",
  "rank": 1,
  "name": "Northland Dental Studio",
  "category": "General dentistry",
  "address": "3307 Northland Dr, Ste 230, Austin, TX 78731",
  "phone": "+15123882220",
  "displayPhone": "+1 512 388 2220",
  "website": "https://www.northlanddentalstudio.com",
  "sourceUrl": "https://www.yelp.com/biz/northland-dental-studio-austin-2",
  "rating": 5,
  "reviewCount": 62,
  "latitude": 30.3347952,
  "longitude": -97.7575592,
  "sourceEngine": "Yelp",
  "scrapedAt": "2026-05-30T00:00:00.000Z"
}
````

### How to run

1. Open the actor on Apify.
2. Add one or more local search queries.
3. Keep the default result limit for a quick first run.
4. Start the actor.
5. Download results as JSON, CSV, Excel, or via API.

### Tips for better results

- Include both category and location in each query.
- Use city names, neighborhoods, or landmarks.
- Use multiple queries for larger lead lists.
- Keep phrases concise.
- Compare related terms such as `dentists`, `orthodontists`, and `dental clinic`.

### Integrations

Use the dataset with:

- CRM enrichment workflows.
- Local SEO dashboards.
- Google Sheets exports.
- Data warehouses.
- Apify webhooks.
- Clay, Make, Zapier, or n8n automations.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/duckduckgo-local-places-scraper').call({
  queries: ['dentists near Austin'],
  maxResultsPerQuery: 20
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/duckduckgo-local-places-scraper').call(run_input={
    'queries': ['coffee shops near Seattle'],
    'maxResultsPerQuery': 20,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~duckduckgo-local-places-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["plumbers in Phoenix"],"maxResultsPerQuery":20}'
```

### MCP usage

Use Apify MCP with Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/duckduckgo-local-places-scraper
```

Claude Code setup:

```bash
claude mcp add apify-duckduckgo-local --transport http https://mcp.apify.com/?tools=automation-lab/duckduckgo-local-places-scraper
```

Claude Desktop JSON config:

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

Example prompts:

- "Run the DuckDuckGo Local Places Scraper for dentists near Austin."
- "Find coffee shops near Seattle and summarize which have websites."
- "Export local roofers in Phoenix to a CSV-ready table."

### Legality

This actor collects publicly available local-search data.

You are responsible for using the data in compliance with applicable privacy, marketing, and database laws.

Do not use scraped contact data for unlawful spam or prohibited outreach.

### Limitations

DuckDuckGo may return fewer than the requested maximum.

DuckDuckGo local results are not available for every query or country.

Some records may miss websites, phones, ratings, or coordinates depending on upstream data.

### FAQ

#### Why did I get no results?

Try a more explicit local query such as `dentists near Austin` instead of just `dentists`.

#### Why are there only about 20 results per query?

DuckDuckGo's local endpoint commonly exposes a compact set of local places. Use multiple queries or locations for larger coverage.

#### Why is a website missing?

DuckDuckGo may know the provider listing but not the business website for every place.

### Related scrapers

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/google-search-scraper
- https://apify.com/automation-lab/bing-search-scraper
- https://apify.com/automation-lab/yelp-scraper

### Changelog

Initial version extracts DuckDuckGo local place records from the public local endpoint.

### Data quality notes

The actor keeps provider IDs when DuckDuckGo exposes them.

It keeps the original provider URL separately from the business website.

It stores coordinates as numbers for easier map usage.

It stores hours as an object because the available day keys can vary.

### Performance

The actor uses HTTP requests, not a browser.

Default memory is 256 MB.

The default delay is conservative for polite repeated queries.

### Best practices

Start with 2-5 queries.

Review a sample dataset before scaling up.

Use exact locations when possible.

Deduplicate downstream by website, phone, or provider ID.

### Example query sets

- `dentists near Austin`
- `orthodontists near Austin`
- `emergency dentist Austin`
- `coffee shops near Seattle`
- `coffee roasters Seattle`
- `plumbers in Phoenix`
- `roofers in Phoenix`
- `vegan restaurants Berlin`

### Support

If a query returns fewer results than expected, include the exact input when requesting support.

This helps reproduce the source response and separate actor issues from DuckDuckGo coverage limits.

### Summary

DuckDuckGo Local Places Scraper is a focused local-business extraction tool for teams that need alternative local search data.

It is designed to be simple, fast, and API-friendly.

Use it when you need business names, contact fields, source links, ratings, and coordinates from DuckDuckGo local results.

# Actor input Schema

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

One or more DuckDuckGo local/place searches. Include the business type and location, for example 'dentists near Austin'.

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

DuckDuckGo usually exposes about 20 local places per query. Use multiple queries for larger lead lists.

## `region` (type: `string`):

DuckDuckGo region/locale hint, for example us-en, uk-en, de-de, fr-fr, or wt-wt.

## `requestDelayMs` (type: `integer`):

Optional polite delay between DuckDuckGo local endpoint requests.

## Actor input object example

```json
{
  "queries": [
    "dentists near Austin",
    "coffee shops near Seattle"
  ],
  "maxResultsPerQuery": 20,
  "region": "us-en",
  "requestDelayMs": 750
}
```

# 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 = {
    "queries": [
        "dentists near Austin",
        "coffee shops near Seattle"
    ],
    "maxResultsPerQuery": 20,
    "region": "us-en",
    "requestDelayMs": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/duckduckgo-local-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 = {
    "queries": [
        "dentists near Austin",
        "coffee shops near Seattle",
    ],
    "maxResultsPerQuery": 20,
    "region": "us-en",
    "requestDelayMs": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/duckduckgo-local-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 '{
  "queries": [
    "dentists near Austin",
    "coffee shops near Seattle"
  ],
  "maxResultsPerQuery": 20,
  "region": "us-en",
  "requestDelayMs": 0
}' |
apify call automation-lab/duckduckgo-local-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DuckDuckGo Local Places Scraper",
        "description": "Extract DuckDuckGo local business results with names, addresses, phones, websites, ratings, coordinates, provider links, and query ranks.",
        "version": "0.1",
        "x-build-id": "qEjtOg0DvGMYmjb00"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~duckduckgo-local-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-duckduckgo-local-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~duckduckgo-local-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-duckduckgo-local-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~duckduckgo-local-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-duckduckgo-local-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "minItems": 1,
                        "type": "array",
                        "description": "One or more DuckDuckGo local/place searches. Include the business type and location, for example 'dentists near Austin'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum places per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "DuckDuckGo usually exposes about 20 local places per query. Use multiple queries for larger lead lists.",
                        "default": 20
                    },
                    "region": {
                        "title": "DuckDuckGo region",
                        "type": "string",
                        "description": "DuckDuckGo region/locale hint, for example us-en, uk-en, de-de, fr-fr, or wt-wt.",
                        "default": "us-en"
                    },
                    "requestDelayMs": {
                        "title": "Delay between queries (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Optional polite delay between DuckDuckGo local endpoint requests.",
                        "default": 750
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```