# Business Address Scraper (`maximedupre/business-address-scraper`) Actor

Find physical business addresses from company websites and export one row per address with source URL, evidence text, parsed fields, and confidence.

- **URL**: https://apify.com/maximedupre/business-address-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

### Get business addresses from company websites

Business Address Scraper finds physical business addresses shown on public company websites. Add domains or website URLs, and the Actor crawls each site page plus same-site pages linked from it, then saves one dataset row per address with the source URL and evidence text.

Use it when you need company address data for lead lists, CRM cleanup, market research, vendor checks, local sales work, or data enrichment. You can run it from the Apify Console, API, schedules, webhooks, or integrations, then export the dataset as JSON, CSV, Excel, or to your app.

For a small first run, keep the prefilled website `apify.com`. You can also paste clean domains like `stripe.com` or full URLs like `https://www.example.com/contact`.

### What this company address scraper does

- Finds website-published business addresses from domains and URLs.
- Emits one row per accepted address.
- Keeps the input domain and seed URL on each row.
- Shows the exact source page where the address was found.
- Adds evidence text so you can check the result.
- Parses street address, city, region, postal code, and country when the site shows them clearly.
- Marks each row with `sourceType` and `confidence`.
- Works with Apify API, exports, schedules, webhooks, and integrations.

The Actor is made for addresses that are visible on the submitted website. It does not use third-party address databases, LLM enrichment, PDF parsing, or store-locator form crawling.

### What data you get

Each row is one physical business address. Fields can be empty when the website does not show that part of the address in a clear way.

- `domain`: normalized input domain
- `seedUrl`: normalized URL used to start the crawl
- `sourceUrl`: page where the address was found
- `fullAddress`: full address text
- `streetAddress`: street address when parsed
- `city`: city when parsed
- `region`: state, region, or province when parsed
- `postalCode`: postal or ZIP code when parsed
- `country`: country when parsed
- `sourceType`: structured data, map link, or visible text
- `confidence`: high, medium, or low
- `evidenceText`: short text that backs up the address

### Common use cases

- Add company addresses to a lead list.
- Clean CRM records from a list of domains.
- Find office addresses for sales research.
- Check vendor or partner location data.
- Build a simple company location dataset.
- Send website address rows to a sheet, CRM, or database.

### How to run it

1. Add one or more websites.
2. Keep the default proxy settings unless you have a reason to change them.
3. Run the Actor.
4. Open the dataset and export the rows.

For a quick test, use 1-5 domains. For larger runs, paste a list of domains and let the Actor emit one row for each address it finds.

### Input

#### Websites

Enter one website per line. You can use clean domains or full URLs:

- `apify.com`
- `stripe.com`
- `https://www.example.com/contact`

The Actor starts from each website and checks same-site HTML pages linked from that first page. It skips files such as PDFs and images.

#### Proxy

The default Apify proxy setting works for most sites. You can change it if a target website needs a different proxy setup.

### Output example

```json
{
  "domain": "stripe.com",
  "seedUrl": "https://stripe.com/en-ca",
  "sourceUrl": "https://stripe.com/en-ca",
  "fullAddress": "350 Bush Street, Floor 13, 94104 San Francisco, CA, US",
  "streetAddress": "350 Bush Street, Floor 13",
  "city": "San Francisco",
  "region": "CA",
  "postalCode": "94104",
  "country": "US",
  "sourceType": "structured-data",
  "confidence": "high",
  "evidenceText": "350 Bush Street, Floor 13, 94104 San Francisco, CA, US"
}
````

### Pricing

This Actor is priced at $7.00 per 1,000 accepted address rows, plus a small Actor start charge. Domains where no address is found do not create address rows.

### Notes and limits

This Actor extracts addresses from public website pages. It may miss addresses that only appear in PDFs, private pages, third-party listings, JavaScript-only store locators, or pages not linked from the first page.

Always review the source URL and evidence text before using address data for legal, compliance, or high-risk work.

### FAQ

#### Does it use Google Maps, LinkedIn, or company databases?

No. The Actor extracts addresses shown on the submitted website. It can read address text from map links on that website, but it does not enrich results from outside databases.

#### Does it return one row per domain?

No. It returns one row per accepted address. If one website shows three office addresses, the dataset can include three rows for that domain.

#### Can I use domains instead of full URLs?

Yes. You can enter `example.com`, and the Actor will start from `https://example.com`.

#### Does it parse PDFs?

No. The Actor crawls HTML pages only.

#### What if no address is found?

The run finishes successfully. That website simply emits no address row.

### Support

Need a field, input format, or source pattern added? Open an issue on the Actor page and include an example website plus the address you expected to find.

# Actor input Schema

## `websites` (type: `array`):

Enter one company website per line. You can use clean domains like stripe.com or full URLs like https://www.example.com/contact.

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

Proxy settings used to load each website and same-site HTML pages linked from the first page. Keep the default unless a site needs a different setup.

## Actor input object example

```json
{
  "websites": [
    "apify.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Dataset of business addresses found on the submitted websites.

# 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 = {
    "websites": [
        "apify.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/business-address-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 = { "websites": ["apify.com"] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/business-address-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 '{
  "websites": [
    "apify.com"
  ]
}' |
apify call maximedupre/business-address-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/business-address-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Business Address Scraper",
        "description": "Find physical business addresses from company websites and export one row per address with source URL, evidence text, parsed fields, and confidence.",
        "version": "0.0",
        "x-build-id": "6PhzABdl8VvflRug4"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~business-address-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-business-address-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/maximedupre~business-address-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-business-address-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/maximedupre~business-address-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-business-address-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": [
                    "websites"
                ],
                "properties": {
                    "websites": {
                        "title": "Websites",
                        "minItems": 1,
                        "type": "array",
                        "description": "Enter one company website per line. You can use clean domains like stripe.com or full URLs like https://www.example.com/contact.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings used to load each website and same-site HTML pages linked from the first page. Keep the default unless a site needs a different setup.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
