# Homebrew Scraper — Formulae, Casks & Install Stats (`hipersoft/homebrew-formulae-scraper`) Actor

Fetch Homebrew formula and cask metadata plus install analytics in bulk. One clean row per package: name, tap, description, homepage, version, license, dependencies and 30/90/365-day install counts. Look up exact names, search the index, or list all. Great for dev tooling and n8n.

- **URL**: https://apify.com/hipersoft/homebrew-formulae-scraper.md
- **Developed by:** [hiper soft](https://apify.com/hipersoft) (community)
- **Categories:** Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.0005 / formula scraped

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Homebrew Scraper — Formulae, Casks & Install Stats

Homebrew Scraper pulls **package metadata and install analytics** from the Homebrew catalog — the package manager for macOS and Linux — as clean, structured data. Look up exact packages by name, filter the entire index by keyword, or export everything. Each **formula** (command-line software) or **cask** (macOS GUI app) comes back as one row with its name, tap, description, homepage, version, license, dependencies and 30-, 90- and 365-day install counts. Export to JSON, CSV, Excel or XML. Built for developer tooling, package dashboards, popularity tracking and automation workflows.

### What does this Homebrew Scraper do?

Give it names, a search term, or the "list all" flag and it returns every matching package as structured data:

- **Look up exact packages** — pass a list of names like `wget`, `node`, `ffmpeg` (or cask tokens such as `google-chrome`).
- **Search the whole index** — filter by a substring matched against the package name, full name and description (e.g. `http`).
- **List everything** — export the full formula or cask catalog, capped by **Max items**.
- **Formulae or casks** — switch the **Type** to read command-line software or macOS GUI apps.

### What data can you get?

| Field | Description |
| --- | --- |
| `name` | Package name / token (e.g. `wget`). |
| `fullName` | Fully-qualified name including tap namespace. |
| `tap` | The tap the package lives in (e.g. `homebrew/core`). |
| `type` | `formula` or `cask`. |
| `description` | Short description of the package. |
| `homepage` | Project homepage URL. |
| `version` | Current stable version. |
| `license` | SPDX license (formulae). |
| `dependencies` | List of required packages. |
| `installs30d` | Installs in the last 30 days. |
| `installs90d` | Installs in the last 90 days. |
| `installs365d` | Installs in the last 365 days. |
| `deprecated` | Whether the package is deprecated. |
| `url` | Canonical package page. |

### What you get

Each package is one clean dataset record. Export the full table to JSON, CSV, Excel or XML, or pull it programmatically.

```json
{
  "name": "wget",
  "fullName": "wget",
  "tap": "homebrew/core",
  "type": "formula",
  "description": "Internet file retriever",
  "homepage": "https://www.gnu.org/software/wget/",
  "version": "1.25.0",
  "license": "GPL-3.0-or-later",
  "dependencies": ["libidn2", "libpsl", "openssl@3", "gettext", "libunistring"],
  "installs30d": 15831,
  "installs90d": 53565,
  "installs365d": 319982,
  "deprecated": false,
  "url": "https://formulae.brew.sh/formula/wget"
}
```

### Use cases

- Track install popularity of packages over 30/90/365-day windows.
- Build a searchable directory of Homebrew formulae and casks.
- Monitor versions and flag deprecated dependencies across your toolchain.
- Enrich a developer dashboard or newsletter with package metadata and trends.
- Export the full catalog for analysis in a spreadsheet or data warehouse.

### How to use the Homebrew Scraper

1. Add the Homebrew Scraper to your Apify account and open its input.
2. Enter package names under **Package names**, and/or a **Search term**, or toggle **List all packages**.
3. Choose the **Type** — Formula or Cask.
4. Set **Max items** to cap search / list-all results.
5. Click **Run**, then export the results as JSON, CSV, Excel or XML, or pull them via the Apify API.

### Input

```json
{
  "formulae": ["wget", "node", "ffmpeg"],
  "type": "formula",
  "maxItems": 100
}
```

| Field | Description |
| --- | --- |
| `formulae` | Array of exact package names (or cask tokens) to look up. |
| `search` | Substring to filter the full index by name/description. |
| `listAll` | Return every package in the catalog (capped by `maxItems`). |
| `type` | `formula` (CLI software) or `cask` (macOS GUI apps). |
| `maxItems` | Maximum number of packages to return. |

### Need more developer & package data?

- [npm Package Scraper](https://apify.com/hipersoft/npm-scraper) — search npm, metadata and download counts.
- [PyPI Scraper](https://apify.com/hipersoft/pypi-scraper) — Python package metadata and releases.
- [Docker Hub Scraper](https://apify.com/hipersoft/docker-hub-scraper) — image metadata, tags and pull stats.

### FAQ

**Which packages are covered?**
The full Homebrew catalog — thousands of formulae (command-line software) and casks (macOS GUI applications) across their taps. Switch the **Type** input to choose which catalog to read.

**Where do the install counts come from?**
Each package carries official Homebrew install analytics for the last 30, 90 and 365 days, returned as `installs30d`, `installs90d` and `installs365d`.

**How do I export everything?**
Set **List all packages** to true and raise **Max items**. You can also combine exact names and a search term in a single run.

**What export formats are supported?**
JSON, CSV, Excel and XML, plus programmatic access through the Apify API.

**How does billing work?**
You pay per package scraped, so cost scales with the number of records you actually collect. See the **Pricing** tab for current rates.

**Can I use this with n8n?**
Yes. Run the Homebrew Scraper from [n8n](https://n8n.io) with the Apify node — trigger a run, pass your names/search/type, and read the dataset items straight into your workflow. It also works with Make, Zapier and the Apify API.

**Can I connect this to other tools?**
The Homebrew Scraper connects with almost any cloud service or web app thanks to [integrations on the Apify platform](https://apify.com/integrations). It works with [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Airbyte](https://docs.apify.com/platform/integrations/airbyte), [GitHub](https://docs.apify.com/platform/integrations/github), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus the [Apify API](https://docs.apify.com/api/v2), JavaScript/Python clients and MCP. Or use [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

### Related Actors

- [npm Package Scraper](https://apify.com/hipersoft/npm-scraper)
- [PyPI Scraper](https://apify.com/hipersoft/pypi-scraper)
- [Docker Hub Scraper](https://apify.com/hipersoft/docker-hub-scraper)

### Notes

Original clean-room implementation. Reads only publicly available package information. Not affiliated with, endorsed by or connected to Homebrew.

# Actor input Schema

## `formulae` (type: `array`):

Exact Homebrew package names to look up, e.g. "wget", "node", "ffmpeg" (or cask tokens like "google-chrome" when Type is Cask). Combined with any search/list results.

## `search` (type: `string`):

Filter the full package index by this substring (matched against the package name, full name and description). Leave empty to skip searching.

## `listAll` (type: `boolean`):

Return every package in the index (capped by Max items). Useful for a full export. Ignores the Search term when enabled.

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

Which Homebrew catalog to read: formulae (command-line software) or casks (macOS GUI apps).

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

Maximum number of packages to return across all inputs. Caps search and list-all results.

## Actor input object example

```json
{
  "formulae": [
    "wget",
    "node",
    "ffmpeg"
  ],
  "search": "http",
  "listAll": false,
  "type": "formula",
  "maxItems": 100
}
```

# Actor output Schema

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

The results as dataset items.

# 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 = {
    "formulae": [
        "wget",
        "node",
        "ffmpeg"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/homebrew-formulae-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 = { "formulae": [
        "wget",
        "node",
        "ffmpeg",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("hipersoft/homebrew-formulae-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "formulae": [
    "wget",
    "node",
    "ffmpeg"
  ]
}' |
apify call hipersoft/homebrew-formulae-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,hipersoft/homebrew-formulae-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/yqAHGZqRUelHtqyfo/builds/WKnN48AjHvzYj8DJL/openapi.json