# Hex.pm Scraper | Elixir and Erlang Packages (`parseforge/hex-pm-scraper`) Actor

Scrape Hex.pm package data including name, version history, downloads, dependencies, owners, repository links, licenses, and release dates. Track the Elixir and Erlang ecosystem, audit dependencies, or build BEAM developer intelligence and security tools for production projects.

- **URL**: https://apify.com/parseforge/hex-pm-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/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 Package Scraper

> 🚀 **Export Elixir and Erlang package data from Hex.pm in seconds.** Search or browse the full **Hex.pm registry** by keyword or sort order, and pull download stats, versions, licenses, links, and timestamps. No API key, no login, no parser maintenance.

> 🕒 **Last updated:** 2026-05-21 · **📊 12 fields** per record · **📦 20,000+ packages** · **🌍 Global Elixir/Erlang ecosystem** · **⚡ Public REST API**

The **Hex.pm Package Scraper** exports structured metadata for every Elixir and Erlang package published to [hex.pm](https://hex.pm) - the package manager for the BEAM ecosystem. Each record captures **12 fields**, including the package name, latest version, description, cumulative and recent download counts, licenses, external links, owner API endpoint, and ingestion timestamps.

Hex.pm is the primary distribution hub for Phoenix, Ecto, LiveView, and thousands of BEAM-compatible libraries. This Actor makes the entire catalog queryable and exportable without you writing a single parser.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Elixir/Erlang developers, open-source researchers, security teams, ecosystem analysts, developer-tool builders, data scientists | Dependency auditing, popularity analysis, ecosystem research, vulnerability triage, trend tracking, OSS discovery |

---

### 📋 What the Hex.pm Package Scraper does

Four workflows in a single run:

- 📦 **Full registry export.** Every public package on Hex.pm sorted by your chosen field.
- 🔍 **Keyword search.** Search for packages matching a term like `phoenix`, `ecto`, or `json`.
- 📊 **Popularity ranking.** Sort by total downloads, recent activity, name, or newest first.
- 🕒 **Timestamped snapshots.** Every record includes `insertedAt`, `updatedAt`, and `scrapedAt` for point-in-time tracking.

Each record includes the package name, direct Hex.pm URL, latest version, description, total and recent downloads, license list, external links object, owners API endpoint, and both Hex.pm timestamps.

> 💡 **Why it matters:** manually browsing Hex.pm is fine for finding one library - but auditing your company's full dependency surface, tracking ecosystem trends, or building a package-search tool requires bulk structured data. This Actor delivers that in under a minute, without touching the HTML.

---

### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>searchQuery</td><td>string</td><td>""</td><td>Filter packages by keyword (e.g. phoenix, ecto). Leave empty to get all packages.</td></tr>
<tr><td>sortBy</td><td>string</td><td>"downloads"</td><td>One of: downloads, recent, name, inserted_at.</td></tr>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: top 100 most downloaded packages.**

```json
{
    "maxItems": 100,
    "sortBy": "downloads"
}
````

**Example: search for JSON-related packages.**

```json
{
    "maxItems": 50,
    "searchQuery": "json",
    "sortBy": "downloads"
}
```

> ⚠️ **Good to Know:** `sortBy: "recent"` ranks by downloads in the last 90 days, not by publication date. Use `inserted_at` to sort by newest packages first.

***

### 📊 Output

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

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📦 `name` | string | `"jason"` |
| 🔗 `url` | string | `"https://hex.pm/packages/jason"` |
| 🏷️ `latestVersion` | string | `"1.5.0-alpha.2"` |
| 📝 `description` | string | `"A blazing fast JSON parser and generator in pure Elixir."` |
| ⬇️ `totalDownloads` | number | `200060803` |
| 📈 `recentDownloads` | number | `4895062` |
| 📜 `licenses` | array | `["Apache-2.0"]` |
| 🔗 `links` | object | `{"GitHub": "https://github.com/michalmuskala/jason"}` |
| 👥 `ownersUrl` | string | `"https://hex.pm/api/packages/jason/owners"` |
| 🗓️ `insertedAt` | ISO 8601 | `"2017-12-22T09:32:40.615828Z"` |
| 🔄 `updatedAt` | ISO 8601 | `"2026-05-05T14:34:54.953586Z"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-21T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>📦 Most downloaded: jason (JSON parser)</strong></summary>

```json
{
    "name": "jason",
    "url": "https://hex.pm/packages/jason",
    "latestVersion": "1.5.0-alpha.2",
    "description": "A blazing fast JSON parser and generator in pure Elixir.",
    "totalDownloads": 200060803,
    "recentDownloads": 4895062,
    "licenses": ["Apache-2.0"],
    "links": {"GitHub": "https://github.com/michalmuskala/jason"},
    "ownersUrl": "https://hex.pm/api/packages/jason/owners",
    "insertedAt": "2017-12-22T09:32:40.615828Z",
    "updatedAt": "2026-05-05T14:34:54.953586Z",
    "scrapedAt": "2026-05-21T01:40:00.458Z",
    "error": null
}
```

</details>

<details>
<summary><strong>📦 Popular HTTP client: hackney</strong></summary>

```json
{
    "name": "hackney",
    "url": "https://hex.pm/packages/hackney",
    "latestVersion": "4.0.0",
    "description": "Simple HTTP client with HTTP/1.1, HTTP/2, and HTTP/3 support",
    "totalDownloads": 167754322,
    "recentDownloads": 3002256,
    "licenses": ["Apache-2.0"],
    "links": {
        "Changelog": "https://github.com/benoitc/hackney/blob/master/NEWS.md",
        "GitHub": "https://github.com/benoitc/hackney"
    },
    "ownersUrl": "https://hex.pm/api/packages/hackney/owners",
    "insertedAt": "2014-08-14T21:51:54.000000Z",
    "updatedAt": "2026-04-16T07:18:23.734241Z",
    "scrapedAt": "2026-05-21T01:40:00.458Z",
    "error": null
}
```

</details>

<details>
<summary><strong>📦 Erlang utility: parse_trans</strong></summary>

```json
{
    "name": "parse_trans",
    "url": "https://hex.pm/packages/parse_trans",
    "latestVersion": "3.4.2",
    "description": "Parse transform library",
    "totalDownloads": 167832073,
    "recentDownloads": 3050116,
    "licenses": ["Apache 2.0"],
    "links": {"Github": "https://github.com/uwiger/parse_trans"},
    "ownersUrl": "https://hex.pm/api/packages/parse_trans/owners",
    "insertedAt": "2015-12-01T11:25:49.826743Z",
    "updatedAt": "2023-10-08T19:11:16.532852Z",
    "scrapedAt": "2026-05-21T01:40:00.458Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📦 | **Full registry access.** 20,000+ packages across the Elixir and Erlang ecosystem in a single run. |
| 🔍 | **Keyword search.** Filter by any term the Hex.pm API supports - library name, description content, or topic. |
| 📊 | **Download analytics.** Both cumulative and 90-day recent downloads in every record. |
| 🔖 | **Rich metadata.** Licenses, external links, owner endpoint, and both Hex.pm timestamps per package. |
| ⚡ | **Fast.** 10 packages in under 5 seconds, 10,000 records in under a minute. |
| 🚫 | **No authentication.** Hex.pm's public API requires no key or login. |
| 🔁 | **Always live.** Every run fetches real-time data - no cached snapshots. |

> 📊 Knowing which packages are most downloaded - and whether that trend is rising or falling - tells you where the Elixir ecosystem is concentrating investment, which libraries are being replaced, and which are safe long-term dependencies.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Hex.pm Package Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **20,000+** packages | **Live per run** | keyword, sort order | ⚡ 2 min |
| Manual Hex.pm browsing | Free | One page at a time | Manual | UI only | 🐢 Hours |
| Hex.pm official CSV exports | Free, rare | Occasional snapshot | Quarterly | None | 🕒 Variable |
| Custom API script | Free (dev time) | Full | On-demand | Custom | 🏗️ Days |

***

### 🚀 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 Package Scraper page on the Apify Store.
3. 🎯 **Set input.** Optionally enter a search term, choose a sort order, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your packages.
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">

#### 🔒 Security and Dependency Auditing

- Inventory which Hex packages your org depends on
- Identify packages with no recent updates or stale versions
- Cross-reference license lists for compliance review
- Flag packages with unusual download spikes (possible compromise signal)

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

#### 📊 Ecosystem and Market Research

- Rank Elixir libraries by download velocity to spot momentum
- Compare download trends across competing packages
- Track when packages are first published vs. when they take off
- Build ecosystem maps by category or license type

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

#### 🛠️ Developer Tooling and Inner Source

- Power package-search autocomplete in your internal developer portal
- Seed a local mirror or cache with the most popular packages
- Build a Slack bot that surfaces trending Hex packages weekly
- Generate weekly digest emails of new packages in a domain

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

#### 🤝 Open Source Discovery and Community

- Discover new or underrated Elixir libraries before they trend
- Find packages with permissive licenses for inclusion in OSS projects
- Identify maintainers via the owners endpoint for collaboration
- Track the release cadence of critical BEAM infrastructure packages

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

***

### 🔌 Automating Hex.pm Package 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. Run it weekly to track how package download rankings shift over time, or daily to catch new publications in a specific category.

***

### 🌟 Beyond business use cases

Data like this 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

- Longitudinal studies on BEAM ecosystem adoption
- Software engineering research on open-source health metrics
- Reproducible package-registry analyses with versioned snapshots
- Comparative studies across registries (npm, PyPI, Crates.io, Hex.pm)

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

#### 🎨 Personal and creative

- Personal dashboards tracking your favorite Elixir libraries
- Side projects and portfolio demos on package analytics
- Content research for Elixir bloggers and newsletter writers
- Visualizations of BEAM ecosystem growth over time

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

#### 🤝 Non-profit and civic

- OSS health reports on critical infrastructure packages
- Community transparency on which packages receive most attention
- Contributions to open package-registry datasets
- Investigative journalism on supply-chain risk in OSS ecosystems

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

#### 🧪 Experimentation

- Train recommendation models on package metadata
- Validate hypotheses about language adoption rates
- Prototype package-monitoring alerting pipelines
- Test dashboard concepts using live registry data

</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%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%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%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%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?

Set optional filters in the input form, click Start, and the Actor calls the public Hex.pm REST API, paginates through results, and emits one clean record per package. No browser automation, no captchas, no credentials.

#### 📦 How many packages does Hex.pm have?

As of mid-2026, Hex.pm hosts over 20,000 packages. The Actor can retrieve all of them in a single paginated run.

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

Every run fetches live data from the Hex.pm API. There is no caching - each run reflects the registry state at run time.

#### 🔍 What search terms does the search filter support?

The `searchQuery` field is passed directly to the Hex.pm API search endpoint. It matches against package names and descriptions. Exact behavior follows the Hex.pm API specification.

#### 📊 What is the difference between totalDownloads and recentDownloads?

`totalDownloads` is the all-time cumulative download count. `recentDownloads` reflects downloads over the past 90 days - useful for spotting momentum rather than legacy popularity.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly, monthly) to track how rankings shift over time or to catch newly published packages.

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

Hex.pm publishes a fully public REST API with no terms prohibiting data collection for non-commercial or commercial research. Review the [Hex.pm terms of service](https://hex.pm/policies/terms) for your specific use case.

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

Yes. Package metadata is public and Hex.pm's API is open. You are responsible for complying with any downstream license terms of the packages you reference.

#### 💳 Do I need a paid Apify plan?

No. The free plan is enough for testing (10 records per run). A paid plan removes the limit and enables scheduling, higher concurrency, and larger datasets.

#### 🔗 Can I get owner details?

Each record includes an `ownersUrl` pointing to the Hex.pm API endpoint for that package's owners. You can query that URL directly to retrieve owner information.

#### 🆘 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 Package 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 run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe 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 push fresh package data into your product backend when a run finishes, or to alert your team in Slack whenever a new package in your stack is updated.

***

### 🔗 Recommended Actors

- [**📦 npm Registry Scraper**](https://apify.com/parseforge/npm-registry-scraper) - JavaScript and Node.js package metadata from npmjs.com
- [**🦀 Crates.io Scraper**](https://apify.com/parseforge/crates-io-scraper) - Rust package registry with download stats and metadata
- [**💎 RubyGems Scraper**](https://apify.com/parseforge/rubygems-scraper) - Ruby gem metadata, versions, and download counts
- [**🐍 PyPI Scraper**](https://apify.com/parseforge/pypi-scraper) - Python package index with classifiers and dependency data
- [**📦 NuGet Scraper**](https://apify.com/parseforge/nuget-scraper) - .NET package registry with version history and stats

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more registry and developer-tool 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, Dashbit, or Erlang Ecosystem Foundation. All trademarks mentioned are the property of their respective owners. Only publicly available data from the Hex.pm public REST API is collected.

# Actor input Schema

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

Filter packages by keyword (e.g. 'phoenix', 'ecto'). Leave empty to get all packages.

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

How to sort the results

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

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

## Actor input object example

```json
{
  "sortBy": "downloads",
  "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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/hex-pm-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-pm-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-pm-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Hex.pm Scraper | Elixir and Erlang Packages",
        "description": "Scrape Hex.pm package data including name, version history, downloads, dependencies, owners, repository links, licenses, and release dates. Track the Elixir and Erlang ecosystem, audit dependencies, or build BEAM developer intelligence and security tools for production projects.",
        "version": "0.1",
        "x-build-id": "bOhJa7fwUlRJfHvbd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~hex-pm-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-hex-pm-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-pm-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-hex-pm-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-pm-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-hex-pm-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Filter packages by keyword (e.g. 'phoenix', 'ecto'). Leave empty to get all packages."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "downloads",
                            "recent",
                            "name",
                            "inserted_at"
                        ],
                        "type": "string",
                        "description": "How to sort the results",
                        "default": "downloads"
                    },
                    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
