# Hex.pm Elixir & Erlang Package Registry Scraper (`parseforge/hex-elixir-packages-scraper`) Actor

Browse and search the Hex.pm registry of Elixir and Erlang packages. Filter by search query, sort by recency, downloads, or alphabetical, and pull versions, dependencies, licenses, and download counts per package.

- **URL**: https://apify.com/parseforge/hex-elixir-packages-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Business, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.50 / 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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📦 Hex.pm Elixir & Erlang Package Registry Scraper

> 🚀 **Export the Hex.pm package registry in seconds.** Browse and search **14,000+ Elixir and Erlang packages** with versions, dependencies, licenses, download counts, owners, and ready-to-paste dependency lines for `mix.exs`, `rebar.config`, and `erlang.mk`. No login, no API key, no manual scraping.

> 🕒 **Last updated:** 2026-05-15 · **📊 30 fields** per record · **📦 14,000+ packages** · **🧪 Elixir + Erlang ecosystems** · **📈 Live download stats**

The **Hex.pm Elixir & Erlang Package Registry Scraper** pulls the official Hex.pm package source and returns **30 fields per package**, including name, description, latest version, full release history, license list, repository URL, all-time and recent download counts, dependency tree of the latest release, build tools, Elixir requirement, publisher, owners, and ready-to-paste dependency lines for the three major BEAM build systems. Hex.pm is the canonical package manager for Elixir and Erlang, used by every production team in the BEAM ecosystem since 2014.

The registry covers **the full Elixir and Erlang ecosystem**, from Phoenix and Ecto down to single-author utility libraries. This Actor exports the catalog as CSV, Excel, JSON, or XML, with sorting by recent downloads, total downloads, recently added, recently updated, or alphabetical. Optional per-package lookups enrich each record with maintainer details and the latest release dependency tree.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| BEAM developers, DevSecOps teams, supply-chain auditors, package-tracker maintainers, conference organizers, recruiters, analysts | Dependency discovery, license auditing, popularity analytics, security review, maintainer mapping, ecosystem reporting |

---

### 📋 What the Hex Packages Scraper does

Five workflows in a single run:

- 🔍 **Search.** Free-text package search across name and description.
- 🏷️ **Sort.** Recent downloads, total downloads, recently added, recently updated, or alphabetical.
- 📦 **Bulk export.** Pull tens of thousands of records with paged listing.
- 👤 **Owner enrichment.** Optional per-package lookup that adds maintainer usernames and emails.
- 🌲 **Latest-release detail.** Optional per-package lookup that adds checksum, dependency tree, build tools, Elixir requirement, and publisher.

Each record carries the latest version (and latest stable, when different), license list, repository URL, full release history with timestamps, all-time / recent / weekly / daily downloads, retirement flags, project links, and the exact dependency line you'd paste into `mix.exs`, `rebar.config`, or `erlang.mk`.

> 💡 **Why it matters:** the BEAM ecosystem ships fast, and dependency choices have outsized impact on uptime and security. Building your own catalog means handling pagination, version logic, and per-package follow-ups. This Actor delivers a clean, ready-to-query dataset on every run.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded Hex package dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>search</code></td><td>string</td><td><code>""</code></td><td>Free-text package search (name and description). Empty = browse the full registry.</td></tr>
<tr><td><code>sort</code></td><td>enum</td><td><code>"recent_downloads"</code></td><td>Recent downloads, total downloads, recently added, recently updated, or alphabetical.</td></tr>
<tr><td><code>fetchOwners</code></td><td>boolean</td><td><code>false</code></td><td>Add per-package maintainer usernames and emails (one extra lookup per package).</td></tr>
<tr><td><code>fetchLatestRelease</code></td><td>boolean</td><td><code>true</code></td><td>Add latest-release dependency tree, checksum, build tools, Elixir requirement, publisher (one extra lookup per package).</td></tr>
</tbody>
</table>

**Example: top 50 most-downloaded packages with full release detail.**

```json
{
    "maxItems": 50,
    "sort": "total_downloads",
    "fetchLatestRelease": true,
    "fetchOwners": false
}
````

**Example: every package matching "phoenix" with maintainer enrichment.**

```json
{
    "maxItems": 100,
    "search": "phoenix",
    "sort": "recent_downloads",
    "fetchOwners": true,
    "fetchLatestRelease": true
}
```

> ⚠️ **Good to Know:** enabling `fetchOwners` or `fetchLatestRelease` makes one extra lookup per package, so a 1,000-package run runs longer than a plain listing-only run. For large bulk exports, leave both off and re-enrich the rows you actually care about.

***

### 📊 Output

Each package record contains **30 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📦 `name` | string | `"phoenix"` |
| 🔗 `packageUrl` | string | `"https://hex.pm/packages/phoenix"` |
| 🔗 `docsUrl` | string | null | `"https://hexdocs.pm/phoenix"` |
| 📝 `description` | string | null | `"Productive. Reliable. Fast."` |
| 🏷️ `latestVersion` | string | `"1.7.18"` |
| 🏷️ `latestStableVersion` | string | null | `"1.7.18"` |
| 📜 `licenses` | string\[] | `["MIT"]` |
| 🔗 `repository` | string | null | `"https://github.com/phoenixframework/phoenix"` |
| 📅 `insertedAt` | ISO 8601 | `"2014-04-18T22:11:30Z"` |
| 🕒 `updatedAt` | ISO 8601 | `"2025-04-12T08:33:11Z"` |
| 📈 `downloadsAll` | number | `41382391` |
| 📈 `downloadsRecent` | number | `624512` |
| 📈 `downloadsWeek` | number | null | `158234` |
| 📈 `downloadsDay` | number | null | `22451` |
| 🔢 `releaseCount` | number | `82` |
| 📦 `releases` | object\[] | `[{"version":"1.7.18","hasDocs":true,"releasedAt":"2025-04-12T..."}]` |
| 🔗 `links` | object | `{"GitHub":"https://github.com/...","Website":"https://www.phoenixframework.org"}` |
| 📦 `mixDependencyLine` | string | null | `"{:phoenix, \"~> 1.7.18\"}"` |
| 📦 `rebarDependencyLine` | string | null | `"{phoenix, \"1.7.18\"}"` |
| 📦 `erlangMkDependencyLine` | string | null | `"dep_phoenix = hex 1.7.18"` |
| 🚦 `isRetired` | boolean | `false` |
| 📝 `retirements` | object | null | (only for retired packages) |
| 🔐 `latestChecksum` | string | null | `"a48ac1...c9d2"` |
| 📈 `latestDownloads` | number | null | `158123` |
| 🏷️ `elixirRequirement` | string | null | `"~> 1.14"` |
| 🛠️ `buildTools` | string\[] | null | `["mix"]` |
| 👤 `latestPublisher` | string | null | `"chrismccord"` |
| 📦 `dependencies` | object\[] | `[{"name":"plug","requirement":"~> 1.14","optional":false}]` |
| 👤 `owners` | object\[] | null | `[{"username":"chrismccord","email":"chris@..."}]` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-15T00:00:00Z"` |
| ❌ `error` | string | undefined | (only when a record fails) |

#### 📦 Sample records

<details>
<summary><strong>📦 Phoenix web framework (top-tier package)</strong></summary>

```json
{
    "name": "phoenix",
    "packageUrl": "https://hex.pm/packages/phoenix",
    "docsUrl": "https://hexdocs.pm/phoenix",
    "description": "Productive. Reliable. Fast. A productive web framework that does not compromise speed or maintainability.",
    "latestVersion": "1.7.18",
    "licenses": ["MIT"],
    "repository": "https://github.com/phoenixframework/phoenix",
    "insertedAt": "2014-04-18T22:11:30Z",
    "updatedAt": "2025-04-12T08:33:11Z",
    "downloadsAll": 41382391,
    "downloadsRecent": 624512,
    "downloadsWeek": 158234,
    "downloadsDay": 22451,
    "releaseCount": 82,
    "releases": [
        {"version": "1.7.18", "hasDocs": true, "releasedAt": "2025-04-12T08:33:11Z"},
        {"version": "1.7.17", "hasDocs": true, "releasedAt": "2025-02-14T11:02:09Z"}
    ],
    "links": {
        "GitHub": "https://github.com/phoenixframework/phoenix",
        "Website": "https://www.phoenixframework.org"
    },
    "mixDependencyLine": "{:phoenix, \"~> 1.7.18\"}",
    "isRetired": false,
    "latestChecksum": "a48ac1...c9d2",
    "latestDownloads": 158123,
    "elixirRequirement": "~> 1.14",
    "buildTools": ["mix"],
    "latestPublisher": "chrismccord",
    "dependencies": [
        {"name": "plug", "requirement": "~> 1.14", "optional": false},
        {"name": "telemetry", "requirement": "~> 0.4 or ~> 1.0", "optional": false}
    ],
    "scrapedAt": "2026-05-15T00:00:00Z"
}
```

</details>

<details>
<summary><strong>🐦 Ecto database wrapper</strong></summary>

```json
{
    "name": "ecto",
    "packageUrl": "https://hex.pm/packages/ecto",
    "docsUrl": "https://hexdocs.pm/ecto",
    "description": "A toolkit for data mapping and language-integrated query for Elixir.",
    "latestVersion": "3.12.5",
    "licenses": ["Apache-2.0"],
    "repository": "https://github.com/elixir-ecto/ecto",
    "downloadsAll": 38219874,
    "downloadsRecent": 542134,
    "releaseCount": 142,
    "mixDependencyLine": "{:ecto, \"~> 3.12.5\"}",
    "isRetired": false,
    "elixirRequirement": "~> 1.11",
    "buildTools": ["mix"],
    "latestPublisher": "josevalim",
    "dependencies": [{"name": "telemetry", "requirement": "~> 0.4 or ~> 1.0", "optional": false}],
    "scrapedAt": "2026-05-15T00:00:00Z"
}
```

</details>

<details>
<summary><strong>🛠️ Erlang library with rebar build tool</strong></summary>

```json
{
    "name": "cowboy",
    "packageUrl": "https://hex.pm/packages/cowboy",
    "docsUrl": "https://hexdocs.pm/cowboy",
    "description": "Small, fast, modern HTTP server.",
    "latestVersion": "2.12.0",
    "licenses": ["ISC"],
    "repository": "https://github.com/ninenines/cowboy",
    "downloadsAll": 12873421,
    "releaseCount": 38,
    "rebarDependencyLine": "{cowboy, \"2.12.0\"}",
    "erlangMkDependencyLine": "dep_cowboy = hex 2.12.0",
    "isRetired": false,
    "buildTools": ["rebar3", "make"],
    "scrapedAt": "2026-05-15T00:00:00Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📦 | **30 fields per package.** Full release history, license list, dependency tree, owners, and ready-to-paste dependency lines. |
| 🛠️ | **Three build systems supported.** `mix.exs`, `rebar.config`, and `erlang.mk` snippets included whenever upstream provides them. |
| 🔍 | **Five sort modes + free-text search.** Find what's new, what's hot, what's classic, alphabetically, or by name. |
| 📈 | **Live download stats.** All-time, recent, weekly, and daily counts surface real adoption signal. |
| 👤 | **Optional owner enrichment.** Add maintainer usernames and emails when you need a contact path. |
| 🌲 | **Optional dependency tree.** Add latest-release dependencies, build tools, Elixir requirement, and checksum on demand. |
| 🚫 | **No authentication.** Works on the public Hex.pm catalog. No login or token required. |

> 📊 The Hex.pm registry is the operating record of the global Elixir and Erlang ecosystem, used by every production BEAM team since 2014.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Hex Packages Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **14,000+ packages** | **Live per run** | search, sort, owner / release enrichment | ⚡ 2 min |
| Manual Hex.pm browsing | Free | Per-page | Manual | None | 🐢 Hours |
| Build your own client | Free | Custom | Manual | Manual | ⏳ Days |
| Static cached dumps | Free | Subset | Stale | None | 🕒 Variable |

Pick this Actor when you want a clean, query-ready Hex catalog with optional owner and dependency enrichment, in seconds.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Hex.pm Elixir & Erlang Package Registry Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a sort, optionally add a search term, decide whether to enrich with owners and release detail, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🛡️ Supply-chain security and audit

- Catalog every dependency of a chosen package
- Flag retired or unmaintained packages
- License inventory for compliance reviews
- Maintainer contact mapping for vulnerability outreach

</td>
<td width="50%" valign="top">

#### 📊 Ecosystem analytics

- Top-N reports by recent or all-time downloads
- Track velocity of new package additions
- License-mix dashboards across the registry
- Build-tool adoption trends (mix vs rebar vs make)

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🧑‍💻 Developer tooling

- Autocomplete and search-engine ingestion
- Dependency-line copy buttons in IDEs
- "Suggest similar packages" features
- Curated weekly newsletter automation

</td>
<td width="50%" valign="top">

#### 📰 Recruiter and conference outreach

- Maintainer lists for sponsorship and talks
- Identify top contributors by published packages
- Surface emerging package authors
- Build BEAM-community contact lists

</td>
</tr>
</table>

***

### 🔌 Automating Hex Packages Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily refreshes catch the new releases and recent-download shifts for ecosystem dashboards.

***

### 🌟 Beyond business use cases

Package-registry data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Empirical software-engineering studies of the BEAM ecosystem
- Reproducible dependency-graph analyses
- Coursework on package management and semantic versioning
- Long-term retirement and abandonment trend studies

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal "starred packages" curation
- Hobbyist BEAM-community newsletters
- Side-project package directories
- Custom dashboards tracking favorite maintainers

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Open-source supply-chain transparency
- BEAM-foundation health metrics reports
- Volunteer-led vulnerability triage
- Community discoverability tools

</td>
<td width="50%">

#### 🧪 Experimentation

- Train ML models on package adoption signals
- Prototype recommendation systems
- Build agent pipelines that audit a project's `mix.exs`
- Validate ecosystem-visualization concepts

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Hex.pm%20Elixir%20%26%20Erlang%20Package%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Hex.pm%20Elixir%20%26%20Erlang%20Package%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Hex.pm%20Elixir%20%26%20Erlang%20Package%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Hex.pm%20Elixir%20%26%20Erlang%20Package%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick a sort, optionally narrow with a search term, decide whether to enrich with owner and latest-release detail, and the Actor pulls one clean structured record per package, with all the metadata your downstream system needs.

#### 🔍 Can I search by package name only?

Yes. The `search` field accepts free text and matches against package name and description. Empty means "browse the full registry sorted as requested."

#### 🔁 How often is the registry refreshed?

Hex.pm publishes new versions continuously. Every Actor run pulls the current state, so download counts and version numbers reflect the latest catalog.

#### 👤 How do I get maintainer emails?

Set `fetchOwners: true`. The Actor will run one extra lookup per package and add the `owners` field with username and email per maintainer (when the maintainer has chosen to make their email public).

#### 🌲 What does latest-release detail add?

`fetchLatestRelease` (default `true`) makes one extra lookup per package and adds the `latestChecksum`, `latestDownloads`, `elixirRequirement`, `buildTools`, `latestPublisher`, and the `dependencies` array of the latest release.

#### ⚡ How fast is a full-registry export?

A plain listing without enrichment runs at roughly 100 packages per page. Adding `fetchOwners` or `fetchLatestRelease` adds two lookups per package. For 14,000 packages with both enrichments, plan on a longer run; for ranking dashboards, leave them off.

#### 📦 What about the dependency-line snippets?

When upstream provides them, the Actor returns ready-to-paste `mixDependencyLine`, `rebarDependencyLine`, and `erlangMkDependencyLine` strings. Paste directly into your build file with no transformation.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to refresh the catalog daily, weekly, or hourly and keep your downstream dashboard or notifier in sync.

#### ⚖️ Is this data legal to use?

Hex.pm publishes the registry openly. Always credit Hex.pm when you redistribute the data verbatim. Review per-package licenses (in the `licenses` field) before redistributing the actual package source.

#### 💼 Can I use this data commercially?

Yes. The registry metadata is open. You are responsible for complying with the individual package licenses if you redistribute the package source itself.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger datasets.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Hex.pm Elixir & Erlang Package Registry Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get new-release notifications in your channels
- [**n8n**](https://docs.apify.com/platform/integrations/n8n) - Drop runs into self-hosted workflows
- [**Pipedream**](https://docs.apify.com/platform/integrations/pipedream) - Trigger event-driven pipelines
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe Hex package data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push retirement alerts into Slack the moment a dependency is flagged, or refresh the package directory on your dev-tooling site nightly.

***

### 🔗 Recommended Actors

- [**📊 jsDelivr Package Stats Scraper**](https://apify.com/parseforge/jsdelivr-package-stats-scraper) - CDN delivery stats for npm and GitHub packages
- [**📦 Crates.io Scraper**](https://apify.com/parseforge/crates-scraper) - Rust crate registry with versions and dependencies
- [**🦫 Go Modules Scraper**](https://apify.com/parseforge/go-modules-scraper) - Go module registry data
- [**🐳 Docker Hub Scraper**](https://apify.com/parseforge/dockerhub-scraper) - Container image stats and tags
- [**👨‍💻 dev.to Scraper**](https://apify.com/parseforge/devto-scraper) - Developer community articles and tags

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Hex.pm, the Hex Foundation, the Erlang Ecosystem Foundation, or any package maintainer. All trademarks mentioned are the property of their respective owners. Only publicly available open registry metadata is collected.

# Actor input Schema

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

Free-text package search (e.g. 'phoenix', 'ecto', 'oban'). Hex also supports advanced query syntax: 'depends:phoenix' returns packages depending on phoenix; 'name:ecto' restricts to package name. Leave empty to browse the full registry.

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

Optional SPDX license identifier to filter by (case-insensitive substring against package licenses, e.g. 'MIT', 'Apache-2.0', 'GPL-3.0').

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

Sort packages by recent updates, total downloads, recent downloads, or name.

## `fetchOwners` (type: `boolean`):

Make an extra lookup per package to include the list of maintainer usernames and emails.

## `fetchLatestRelease` (type: `boolean`):

Make an extra lookup per package to include the latest release dependency tree, requirements, and checksum.

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

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

## Actor input object example

```json
{
  "search": "",
  "license": "",
  "sort": "recent_downloads",
  "fetchOwners": false,
  "fetchLatestRelease": true,
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

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

Complete dataset

# 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
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/hex-elixir-packages-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 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/hex-elixir-packages-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
}' |
apify call parseforge/hex-elixir-packages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hex.pm Elixir & Erlang Package Registry Scraper",
        "description": "Browse and search the Hex.pm registry of Elixir and Erlang packages. Filter by search query, sort by recency, downloads, or alphabetical, and pull versions, dependencies, licenses, and download counts per package.",
        "version": "0.0",
        "x-build-id": "sX7WRSoaKvfW00H2q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~hex-elixir-packages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-hex-elixir-packages-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~hex-elixir-packages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-hex-elixir-packages-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~hex-elixir-packages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-hex-elixir-packages-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": {
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Free-text package search (e.g. 'phoenix', 'ecto', 'oban'). Hex also supports advanced query syntax: 'depends:phoenix' returns packages depending on phoenix; 'name:ecto' restricts to package name. Leave empty to browse the full registry.",
                        "default": ""
                    },
                    "license": {
                        "title": "License Filter (SPDX)",
                        "type": "string",
                        "description": "Optional SPDX license identifier to filter by (case-insensitive substring against package licenses, e.g. 'MIT', 'Apache-2.0', 'GPL-3.0').",
                        "default": ""
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "recent_downloads",
                            "total_downloads",
                            "inserted_at",
                            "updated_at",
                            "name"
                        ],
                        "type": "string",
                        "description": "Sort packages by recent updates, total downloads, recent downloads, or name.",
                        "default": "recent_downloads"
                    },
                    "fetchOwners": {
                        "title": "Fetch Package Owners",
                        "type": "boolean",
                        "description": "Make an extra lookup per package to include the list of maintainer usernames and emails.",
                        "default": false
                    },
                    "fetchLatestRelease": {
                        "title": "Fetch Latest Release Detail",
                        "type": "boolean",
                        "description": "Make an extra lookup per package to include the latest release dependency tree, requirements, and checksum.",
                        "default": true
                    },
                    "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"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
