# Open Brewery DB Scraper (`parseforge/open-brewery-db-scraper`) Actor

Scrape brewery listings across the United States. Get brewery names, types (micro, brewpub, large, contract), full addresses, GPS coordinates, phone numbers, and websites for 8,000+ breweries. Filter by state, city, brewery type, and postal code. Great for lead generation and market analysis.

- **URL**: https://apify.com/parseforge/open-brewery-db-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.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.
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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🍺 Open Brewery DB Scraper

Whether you're building a craft beer directory, researching the brewery industry, or planning brewery tours across the United States, this tool makes it easy to collect structured brewery data with names, types, addresses, phone numbers, websites, and GPS coordinates.

> **The Open Brewery DB Scraper collects brewery listings with names, types, full addresses, phone numbers, website URLs, and geographic coordinates. Filter by state, city, brewery type, and postal code.**

### ✨ What Does It Do

- 🏭 **Brewery listings** - collect names, types, and contact details for breweries across the United States
- 📍 **Full addresses** - extract street addresses, cities, states, postal codes, and countries
- 📞 **Contact info** - get phone numbers and website URLs for each brewery
- 🗺️ **GPS coordinates** - retrieve latitude and longitude for mapping and geospatial analysis
- 🔍 **Location filters** - search by state, city, or postal code
- 🏷️ **Type filtering** - narrow results by brewery type: micro, nano, regional, brewpub, large, and more

### 🔧 Input

- **State** - filter breweries by US state (e.g., 'California', 'New York', 'Texas')
- **Max Items** - how many breweries to collect (free users get 10 items, paid users up to 1,000,000)
- **City** - optional city filter within the selected state
- **Brewery Type** - filter by type: Micro, Nano, Regional, Brewpub, Large, Planning, Bar, Contract, Proprietor, or Closed
- **Sort By** - sort results by name, city, state, or type
- **Postal Code** - filter by zip code (e.g., '44107' or '44107-9863')

```json
{
    "state": "California",
    "maxItems": 50,
    "breweryType": "micro",
    "sort": "name"
}
````

### 📊 Output

Each brewery record includes up to 15+ data fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| 📋 name | Brewery name |
| 🏷️ breweryType | Type (micro, nano, brewpub, etc.) |
| 📍 address1 | Street address |
| 🏙️ city | City |
| 🗺️ stateProvince | State or province |
| 📮 postalCode | Postal/zip code |
| 🌍 country | Country |
| 📞 phone | Phone number |
| 🔗 websiteUrl | Website URL |
| 📍 latitude | GPS latitude |
| 📍 longitude | GPS longitude |

```json
{
    "id": "sierra-nevada-brewing-co-chico",
    "name": "Sierra Nevada Brewing Co",
    "breweryType": "regional",
    "address1": "1075 E 20th St",
    "city": "Chico",
    "stateProvince": "California",
    "postalCode": "95928-6722",
    "country": "United States",
    "phone": "5308932520",
    "websiteUrl": "http://www.sierranevada.com",
    "longitude": "-121.7867",
    "latitude": "39.7242",
    "street": "1075 E 20th St",
    "scrapedAt": "2026-04-09T12:00:00.000Z"
}
```

### 💎 Why Choose the Open Brewery DB Scraper?

| Feature | Our Tool | Manual Searching |
|---------|----------|-----------------|
| Batch collection | ✅ Up to 1M breweries | ❌ Look up one at a time |
| GPS coordinates | ✅ Lat/lng included | ⚠️ Not always available |
| Multiple filters | ✅ State, city, type, postal code | ⚠️ Limited search |
| Structured output | ✅ JSON, CSV, Excel | ❌ Web pages only |
| Automated scheduling | ✅ Daily/weekly updates | ❌ Manual visits |
| Contact details | ✅ Phone + website included | ⚠️ Scattered across pages |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your state, city, brewery type, and how many results you want
3. **Run It** - click "Start" and get structured brewery data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 🍺 **Beer enthusiasts** - build brewery tour itineraries with addresses, websites, and GPS coordinates
- 📊 **Market researchers** - analyze the craft beer industry by state, city, and brewery type
- 🗺️ **App developers** - create brewery finder apps with location data and contact information
- 📰 **Journalists** - research the craft beer landscape for industry reports and trend pieces
- 🏪 **Distributors** - identify breweries by region and type for sales prospecting
- 📱 **Tourism companies** - build brewery tour packages with accurate addresses and phone numbers

### ❓ FAQ

🍺 **What is Open Brewery DB?**
Open Brewery DB is an open-source dataset of breweries, primarily covering the United States. It includes detailed information about brewery types, locations, and contact details.

🏷️ **What brewery types are available?**
Types include Micro (small-scale), Nano (very small), Regional (medium-large), Brewpub (restaurant-brewery), Large (major producers), Planning (in planning stages), Bar, Contract, Proprietor, and Closed.

📍 **Do all breweries have GPS coordinates?**
Most breweries include latitude and longitude, but some entries may have missing coordinate data.

🗺️ **Is this US-only?**
The database primarily covers the United States, though some international breweries may be included.

📅 **How current is the data?**
The database is community-maintained and updated regularly. Schedule periodic runs to keep your data fresh.

### 🔗 Integrate Open Brewery DB Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate brewery data workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts for new breweries in your area
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export brewery data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more data collection tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Hugging Face Model Scraper | Collect AI model data from Hugging Face | [Link](https://apify.com/parseforge/hugging-face-model-scraper) |
| Smart Apify Actor Scraper | Scrape actor data with 70+ fields | [Link](https://apify.com/parseforge/smart-apify-actor-scraper) |
| Greatschools Scraper | Collect school ratings and data | [Link](https://apify.com/parseforge/greatschools-scraper) |
| PR Newswire Scraper | Collect press releases and news | [Link](https://apify.com/parseforge/pr-newswire-scraper) |
| HTML to JSON Smart Parser | Parse any web page into structured data | [Link](https://apify.com/parseforge/html-to-json-smart-parser) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to Open Brewery DB or its maintainers. It accesses only publicly available data.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `state` (type: `string`):

Filter breweries by US state (e.g., California, New York, Texas).

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

Optional: Filter breweries by city.

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

Filter breweries by postal/zip code (e.g., '44107' or '44107-9863').

## `breweryType` (type: `string`):

Filter by brewery type.

## `sort` (type: `string`):

Sort results by this field.

## Actor input object example

```json
{
  "maxItems": 10,
  "state": "California"
}
```

# 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 = {
    "maxItems": 10,
    "state": "California"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/open-brewery-db-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 = {
    "maxItems": 10,
    "state": "California",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/open-brewery-db-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 '{
  "maxItems": 10,
  "state": "California"
}' |
apify call parseforge/open-brewery-db-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Open Brewery DB Scraper",
        "description": "Scrape brewery listings across the United States. Get brewery names, types (micro, brewpub, large, contract), full addresses, GPS coordinates, phone numbers, and websites for 8,000+ breweries. Filter by state, city, brewery type, and postal code. Great for lead generation and market analysis.",
        "version": "0.0",
        "x-build-id": "tUMoIKTYW4ZwusF6a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~open-brewery-db-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-open-brewery-db-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/parseforge~open-brewery-db-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-open-brewery-db-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/parseforge~open-brewery-db-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-open-brewery-db-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": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "state": {
                        "title": "State",
                        "type": "string",
                        "description": "Filter breweries by US state (e.g., California, New York, Texas)."
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Optional: Filter breweries by city."
                    },
                    "postalCode": {
                        "title": "Postal Code",
                        "type": "string",
                        "description": "Filter breweries by postal/zip code (e.g., '44107' or '44107-9863')."
                    },
                    "breweryType": {
                        "title": "Brewery Type",
                        "enum": [
                            "",
                            "micro",
                            "nano",
                            "regional",
                            "brewpub",
                            "large",
                            "planning",
                            "bar",
                            "contract",
                            "proprietor",
                            "closed"
                        ],
                        "type": "string",
                        "description": "Filter by brewery type."
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "",
                            "name",
                            "city",
                            "state",
                            "type"
                        ],
                        "type": "string",
                        "description": "Sort results by this field."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
