# Hex.pm Packages Scraper (`parseforge/hexpm-elixir-packages-scraper`) Actor

Scrapes Hex.pm packages by search query and returns each package as a flat row with name, version, downloads, and metadata.

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

## Pricing

from $19.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/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Hex.pm Packages Scraper

**Scrape Hex.pm packages by search query, up to a million per run.** Every package comes with its name, version, downloads, and metadata. No login or API key. Export to CSV, JSON, Excel, or XML.

Hex.pm is the official package registry for Elixir and Erlang, but browsing it manually is slow and the API requires authentication. This Actor reads the public package list directly, filtered by search term, and returns each match in one fixed schema.

| Who uses it | What they scrape Hex.pm for |
|---|---|
| Elixir developers | Which libraries are available for a given task |
| Erlang developers | Which packages are actively maintained |
| Market researchers | Which packages are trending in the Elixir ecosystem |
| DevOps engineers | Which dependencies a project should pin |

### What it does

This Actor collects Hex.pm packages by search query and returns each one as a flat row.

- 🔍 **Search by keyword:** find packages by name or description, like phoenix or ecto.
- 📦 **Full package list:** leave the search empty to browse every package on Hex.pm.
- ⚙️ **Flexible limits:** collect from 1 to 1,000,000 packages per run.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Hex.pm data

**📈 Track package popularity.**

A developer runs the Actor weekly with a search for 'phoenix' to see which related packages are gaining downloads and decide what to adopt.

**🔎 Audit dependencies.**

A DevOps engineer scrapes all packages used by a project to check their latest versions and licenses before a release.

**🧪 Research the ecosystem.**

A market researcher collects the full package list to analyze which categories are growing and which are stagnant.

**📚 Build a package index.**

A startup scrapes Hex.pm daily to populate its own searchable database of Elixir libraries.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Scrape Hex.pm without registering an application or managing tokens. |
| **One fixed schema** | Every package returns the same fields, so you can merge runs without cleaning. |
| **Export anywhere** | Download as CSV, JSON, Excel, or XML, or push to Apify storage. |

### How it compares

This Actor focuses on search-driven scraping with a high item limit, while competitors offer different field sets or pricing models.

| Feature | ParseForge | Hexpm Scraper | Hex.pm Package Scraper | Hex.pm Scraper - Elixir & Erlang Packages |
|---|---|---|---|---|
| Search by keyword | Yes | Not listed | Yes | Not listed |
| Fetch by package name | Not listed | Not listed | Yes | Not listed |
| Download statistics | Yes | Yes | Yes | Yes |
| Version history | Not listed | Yes | Not listed | Not listed |
| License information | Not listed | Not listed | Yes | Yes |
| Repository links | Not listed | Not listed | Yes | Not listed |
| Max items per run | 1,000,000 | Not listed | Not listed | Not listed |

### Configure the run

Drive the Actor with a search query, and set a maximum number of packages to collect. The search runs as each package is read, so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "searchQuery": "phoenix",
 "maxItems": 10
}
```

A larger pull:

```json
{
 "searchQuery": "phoenix",
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Hex.pm Packages Scraper](https://apify.com/parseforge/hexpm-elixir-packages-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Hex.pm through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/hexpm-elixir-packages-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your search query. If it is too specific, try a broader term. Also ensure the maximum packages is set high enough.

**Why is the run slow?**

Hex.pm may rate-limit requests. Reduce the maximum packages or add a delay between requests if the platform allows.

**Why are some fields empty?**

Not all packages have every metadata field. Empty fields mean the data is not available on the public listing.

**Can I scrape a specific package by name?**

Yes. Enter the exact package name in the search query, and it will return that package if it exists.

### FAQ

| Question | Answer |
|---|---|
| Do I need a Hex.pm API key? | No. This Actor reads the public package list directly, so no authentication is required. |
| Can I scrape all packages on Hex.pm? | Yes. Leave the search query empty and set a high maximum to collect the full list, up to one million packages per run. |
| What data does each package include? | Each row includes the package name, latest version, download count, and other metadata available on the public listing. |
| How do I filter packages? | Use the search query field to match package names or keywords. The filter is applied as packages are read, so only matches are returned. |
| Can I export the results? | Yes. You can download the dataset as CSV, JSON, Excel, or XML, or access it via the Apify API. |
| Is there a limit on how many packages I can scrape? | You can set the maximum packages per run from 1 to 1,000,000. The default is 10. |
| Does this work for Erlang packages too? | Yes. Hex.pm hosts both Elixir and Erlang packages, and this Actor scrapes both. |
| Can I schedule this Actor to run automatically? | Yes. Use Apify's scheduler to run it daily, weekly, or on any cron schedule. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Hex.pm. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Optional. Term to search Hex.pm packages for (for example phoenix, ecto, plug). Leave empty to browse the full package list.

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

How many packages to collect per run.

## Actor input object example

```json
{
  "searchQuery": "phoenix",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "phoenix",
    "maxItems": 10
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/hexpm-elixir-packages-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/CwPnwF0cI7LlgbzEK/builds/8dOsPAfktlqh2gc5N/openapi.json