# RubyGems Package Release Monitor (`automation-lab/rubygems-package-release-monitor`) Actor

💎 Monitor RubyGems releases, dependencies, licenses, downloads, and version changes across your Ruby package allowlist.

- **URL**: https://apify.com/automation-lab/rubygems-package-release-monitor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## RubyGems Package Release Monitor

Monitor a RubyGems allowlist for package releases, dependencies, licenses, and download signals.

### What does it do?

This Actor reads public RubyGems API data for the gem names you provide.

It returns one normalized package record per gem.

Use it to turn a Ruby dependency list into structured, repeatable monitoring data.

No RubyGems account, browser session, or proxy is required.

### Who is it for?

#### Ruby engineering and platform teams

Run a scheduled allowlist check after deployments or dependency-update pull requests. The output gives your team a dated version, license, dependency, and download snapshot without opening each RubyGems page by hand.

#### Rails agencies and consultants

Submit the gem lists used by several client applications, then export only records where `versionChanged` is `true`. This creates a repeatable release-review queue and a clear audit trail for each client portfolio.

#### Security and software supply-chain teams

Use the dependency arrays and license fields as a lightweight registry signal alongside your SBOM workflow. A changed version or license can trigger a focused review before a package update reaches production.

#### Data and developer-experience teams

Land normalized RubyGems metadata in a warehouse or spreadsheet, join it to internal service ownership, and report release cadence or download movement across the approved package catalog.

### Why use this monitor?

A manual registry check is easy to forget and difficult to audit.

Schedule this Actor to keep a machine-readable snapshot of your approved gems.

The optional snapshot mode flags a changed current version between runs.

### Data returned

| Field | Description |
| --- | --- |
| `name` | RubyGems package name |
| `currentVersion` | Current released version |
| `releaseTimestamp` | Current version release time |
| `totalDownloads` | All-time gem downloads |
| `versionDownloads` | Downloads for the current version |
| `licenses` | Registry license labels |
| `runtimeDependencies` | Runtime dependency requirements |
| `developmentDependencies` | Development dependency requirements |
| `versionHistory` | Optional recent version history |

### Quick start

1. Add one or more gem names in **Gem names**.
2. Leave snapshot comparison enabled for recurring monitoring.
3. Run the Actor.
4. Export the dataset to JSON, CSV, or your preferred destination.

### Input: gem names

Provide RubyGems names, not GitHub repository URLs.

For example: `rails`, `sidekiq`, `nokogiri`, or `devise`.

Duplicate and blank names are removed before requests are made.

The default input intentionally uses a small list for a low-cost first run.

### Input: version history

Enable **Include version history** to add recent releases to each package record.

Use **Maximum versions per gem** to bound this enrichment.

This is useful for release cadence reports and change reviews.

### Input: snapshot comparison

Snapshot comparison stores each package's last observed current version in the Actor key-value store.

On later runs, `versionChanged`, `previousVersion`, `firstSeenAt`, and `lastSeenAt` describe the observed change.

Use the same Actor storage when scheduling monitoring runs.

### Input: concurrency

The Actor defaults to three parallel requests.

RubyGems is a shared public service, so leave concurrency low for normal monitoring.

Increase it only for a large internal allowlist when your workflow needs faster completion.

### Output: package records

Every successful record includes retrieval time and the exact RubyGems API source URL.

Homepage and source-code URLs are retained when the registry provides them.

Dependencies are structured arrays with a package name and requirement string.

Authors and licenses are normalized into arrays for exports and integrations.

### Partial-result errors

One inaccessible or misspelled gem does not stop the rest of the run.

Instead, the dataset contains a record with `name`, `sourceUrl`, `retrievedAt`, and `error`.

Correct the failed name and rerun only that item if needed.

### How much does it cost to monitor RubyGems packages?

The Actor charges one $0.005 start event plus one result event for every package record, including a typed error record for a misspelled or unavailable gem. Prices below use the configured event rates; your Apify plan credits and account billing rules determine what you ultimately pay.

| Example run | FREE tier estimate | BRONZE tier estimate |
| --- | ---: | ---: |
| 2 packages | $0.00506 | $0.00505 |
| 25 packages | $0.00571 | $0.00562 |
| 100 packages | $0.00784 | $0.00747 |

For a free-plan estimate, a 100-package monitoring run at the FREE event tier is about **$0.00784** before any account-level credits. The live pricing panel is authoritative and shows the discounted SILVER, GOLD, PLATINUM, and DIAMOND tiers.

### Schedule release checks

Create an Apify schedule with your stable gem allowlist input.

Daily or weekly schedules work well for dependency maintenance.

Send the dataset to a webhook, Google Sheets, or your own deployment dashboard.

### Integrations

- Send `versionChanged: true` records to Slack or Microsoft Teams.
- Join dependency arrays with an internal software-bill-of-materials dataset.
- Compare download changes with release timestamps in a warehouse.
- Trigger a security review when a license label changes.

### API usage: Node.js

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rubygems-package-release-monitor').call({
  gemNames: ['rails', 'sidekiq'], snapshotComparison: true,
});
console.log(run.defaultDatasetId);
````

### API usage: Python

```python
from apify_client import ApifyClient
client = ApifyClient(token='APIFY_TOKEN')
run = client.actor('automation-lab/rubygems-package-release-monitor').call(
    run_input={'gemNames': ['rails', 'sidekiq'], 'snapshotComparison': True}
)
print(run['defaultDatasetId'])
```

### API usage: cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~rubygems-package-release-monitor/runs?token=APIFY_TOKEN' \
  -H 'content-type: application/json' \
  -d '{"gemNames":["rails","sidekiq"],"snapshotComparison":true}'
```

### MCP with Claude, Cursor, and VS Code

Connect the Actor-specific HTTP MCP endpoint so your client exposes only this monitor:

`https://mcp.apify.com?tools=automation-lab/rubygems-package-release-monitor`

#### Claude Code (HTTP)

```bash
claude mcp add --transport http apify-rubygems https://mcp.apify.com?tools=automation-lab/rubygems-package-release-monitor
```

Restart Claude Code or reload its MCP tools after adding the server. Authenticate with your Apify account when the client asks for it.

#### Claude Desktop

Add this entry to the `mcpServers` object in Claude Desktop's MCP configuration, save it, and restart Claude Desktop:

```json
{
  "mcpServers": {
    "apify-rubygems": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/rubygems-package-release-monitor"
    }
  }
}
```

#### Cursor or VS Code

In your MCP server configuration (for example Cursor MCP settings or VS Code's MCP configuration), add the same HTTP server definition and reload the editor window:

```json
{
  "servers": {
    "apify-rubygems": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/rubygems-package-release-monitor"
    }
  }
}
```

Example prompts — try asking these after connecting:

- “Monitor `rails`, `sidekiq`, and `nokogiri`; list any package whose current version changed.”
- “Fetch the last 10 versions of `devise` and summarize its recent release cadence.”
- “Check this RubyGems allowlist and flag records whose license or runtime dependencies need supply-chain review.”

### Legality and responsible use

This Actor calls public RubyGems registry endpoints.

You are responsible for complying with RubyGems terms, your organization’s policies, and applicable law.

Use conservative concurrency and avoid unnecessary repeated requests.

### Reliability notes

RubyGems may temporarily rate-limit or change API fields.

The Actor logs per-gem failures and continues with unaffected names.

Version history is optional so a standard monitoring run stays lightweight.

### Tips

Use exact canonical gem names from your `Gemfile.lock` or software inventory.

Keep snapshots enabled when you care about release deltas.

Export nested dependencies as JSON when your downstream tool supports it.

### Troubleshooting

**Why is a record marked with an error?** The gem may be misspelled, removed, or temporarily unavailable from RubyGems.

**Why is `versionChanged` false on my first run?** There is no prior snapshot yet; the first run establishes the baseline.

**Why is version history empty?** Disable and re-enable the option only after confirming the package has released versions in RubyGems.

### FAQ

**Does this install or execute gems?** No. It only retrieves public registry metadata.

**Does it require a RubyGems login?** No. The normal API route is public.

**Can I monitor hundreds of packages?** Yes. Use a conservative concurrency setting and schedule the allowlist.

### Related scrapers

- [Packagist Composer Package Intelligence Monitor](https://apify.com/automation-lab/packagist-composer-package-intelligence-monitor) — monitor Composer packages for PHP application portfolios.
- [Maven Central Artifact Dependency Monitor](https://apify.com/automation-lab/maven-central-artifact-dependency-monitor) — monitor Java and JVM artifact releases and dependencies.

Use this Actor for RubyGems metadata and Ruby dependency teams; combine all three exports when your organization operates polyglot services.

### Changelog

See [the Actor changelog](.actor/CHANGELOG.md) for user-facing release notes.

### Support

Include the gem name, input options, and relevant log line when reporting a problem.

That lets us distinguish a package-specific registry response from an Actor issue.

# Actor input Schema

## `gemNames` (type: `array`):

RubyGems package names to monitor. One dataset record is produced per name.

## `includeVersionHistory` (type: `boolean`):

Fetch recent released versions for each gem.

## `maxVersions` (type: `integer`):

Recent version rows to include when version history is enabled.

## `snapshotComparison` (type: `boolean`):

Persist the last seen version and flag version changes between runs.

## `maxConcurrency` (type: `integer`):

Parallel RubyGems API requests. Keep this low to be respectful of the registry.

## Actor input object example

```json
{
  "gemNames": [
    "rails",
    "sidekiq"
  ],
  "includeVersionHistory": false,
  "maxVersions": 20,
  "snapshotComparison": true,
  "maxConcurrency": 3
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "gemNames": [
        "rails",
        "sidekiq"
    ],
    "includeVersionHistory": false,
    "maxVersions": 20,
    "snapshotComparison": true,
    "maxConcurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rubygems-package-release-monitor").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 = {
    "gemNames": [
        "rails",
        "sidekiq",
    ],
    "includeVersionHistory": False,
    "maxVersions": 20,
    "snapshotComparison": True,
    "maxConcurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rubygems-package-release-monitor").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 '{
  "gemNames": [
    "rails",
    "sidekiq"
  ],
  "includeVersionHistory": false,
  "maxVersions": 20,
  "snapshotComparison": true,
  "maxConcurrency": 3
}' |
apify call automation-lab/rubygems-package-release-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/rubygems-package-release-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "RubyGems Package Release Monitor",
        "description": "💎 Monitor RubyGems releases, dependencies, licenses, downloads, and version changes across your Ruby package allowlist.",
        "version": "0.1",
        "x-build-id": "QcCMsORskSxT6ya93"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~rubygems-package-release-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-rubygems-package-release-monitor",
                "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/automation-lab~rubygems-package-release-monitor/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-rubygems-package-release-monitor",
                "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/automation-lab~rubygems-package-release-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-rubygems-package-release-monitor",
                "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",
                "required": [
                    "gemNames"
                ],
                "properties": {
                    "gemNames": {
                        "title": "💎 Gem names",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "RubyGems package names to monitor. One dataset record is produced per name.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeVersionHistory": {
                        "title": "Include version history",
                        "type": "boolean",
                        "description": "Fetch recent released versions for each gem.",
                        "default": false
                    },
                    "maxVersions": {
                        "title": "Maximum versions per gem",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Recent version rows to include when version history is enabled.",
                        "default": 20
                    },
                    "snapshotComparison": {
                        "title": "Compare with prior snapshot",
                        "type": "boolean",
                        "description": "Persist the last seen version and flag version changes between runs.",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Request concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Parallel RubyGems API requests. Keep this low to be respectful of the registry.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```