# Artifact Hub Helm Charts Scraper (`b2b_lead_generation/artifact-hub-helm-charts-scraper`) Actor

Search and export public Helm charts and Kubernetes operators into structured JSON, CSV, or Excel datasets. Track versions, publishers, star counts, and CVE summaries instantly without configuration.

- **URL**: https://apify.com/b2b_lead_generation/artifact-hub-helm-charts-scraper.md
- **Developed by:** [B2B Lead Generation](https://apify.com/b2b_lead_generation) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Artifact Hub Scraper: Helm Chart and Operator Search

This scraper lets you easily search and gather public Helm charts and Kubernetes operators in one clean dataset. It collects version histories, stars, publishers, and security report details so you can export your findings as JSON, CSV, or Excel without hassle.

### Use cases

- **Cluster fleet inventory**: Keep track of the Helm charts currently deployed across your environments and match exact versions in a single dataset.
- **Operator shortlist**: Collect verified operator packages right alongside your standard Helm charts.
- **Publisher check**: Filter and review verified publishers before deploying new charts to your production repositories.
- **CVE glance**: Quickly review security report summaries directly within your dataset rows.
- **Scheduled export**: Run regular checks and automatically route your datasets to spreadsheets, team channels, or data warehouses.
- **Chart lookup**: Pull detailed records for specific charts when doing targeted audits.

### What data does this actor extract?

The scraper pulls package details, descriptions, star counts, publisher metadata, and security vulnerability summaries. Duplicate entries are automatically filtered out by package identifier, and failed requests are cleanly logged as error rows rather than halting your entire run.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | Choose between package search or specific detail lookup |
| `query` | string | `postgres` | Keywords or search terms |
| `kinds` | array | `[0]` | Package kinds (`0` for Helm charts) |
| `verifiedPublisherOnly` | boolean | `false` | Restrict results to verified publishers only |
| `packages` | array | `bitnami/postgresql` | Specific chart names for detail mode |
| `maxItems` | integer | `100` | Maximum items to collect per run (up to 1000) |
| `requestDelaySecs` | number | `1` | Delay between requests |
| `userAgent` | string | B2B Lead Generation research UA | Custom user agent string |
| `timeoutSecs` | integer | `300` | Maximum run duration in seconds |
| `requestTimeoutSecs` | integer | `30` | Individual request timeout |
| `proxyConfiguration` | object | `{"useApifyProxy": false}` | Optional proxy settings |

#### Example input configuration

```json
{
    "mode": "search",
    "query": "postgres",
    "kinds": [0],
    "verifiedPublisherOnly": false,
    "packages": ["bitnami/postgresql"],
    "maxItems": 100,
    "requestDelaySecs": 1,
    "userAgent": "",
    "timeoutSecs": 300,
    "requestTimeoutSecs": 30,
    "proxyConfiguration": { "useApifyProxy": false }
}

```

### Output data structure

```json
{
    "package_id": "c617753b-3376-40a1-81a1-3ab00e2868ac",
    "name": "postgresql",
    "version": "18.12.4",
    "app_version": "18.6.0",
    "chartDescription": "PostgreSQL (Postgres) is an open source object-relational database known for reliability and data integrity.",
    "stars": 430,
    "signed": true,
    "security_report_summary": {
        "low": 0,
        "high": 1,
        "medium": 0,
        "unknown": 0,
        "critical": 0
    },
    "production_organizations_count": 10,
    "repository_name": "bitnami",
    "repository_url": "https://charts.bitnami.com/bitnami",
    "verified_publisher": true,
    "organization": "Bitnami",
    "scraped_at": "2026-10-12T00:00:00+00:00"
}

```

| Field | Type | Description |
| --- | --- | --- |
| `package_id` | string | Unique package identifier |
| `name` | string | Name of the chart or package |
| `version` | string | Chart release version |
| `app_version` | string | Underlying application version |
| `chartDescription` | string | Short summary text |
| `stars` | integer | Community star count |
| `signed` | boolean | Package signature status |
| `security_report_summary` | object | Vulnerability counts grouped by severity |
| `production_organizations_count` | integer | Number of organizations reporting usage |
| `repository_name` | string | Helm repository name |
| `repository_url` | string | Helm repository web link |
| `verified_publisher` | boolean | Publisher verification flag |
| `organization` | string | Display name of the publisher organization |
| `scraped_at` | string | Timestamp when the row was recorded |

***

#### Trademark Notice

All product names, logos, and brands are property of their respective owners. All company, product and service names used in this documentation are for identification purposes only. Use of these names, logos, and brands does not imply endorsement.

#### Disclaimer

This actor is an independent utility created to help developers gather public data efficiently. It is not officially affiliated with or endorsed by the target platforms. Users remain responsible for adhering to applicable terms of service and data usage policies.

#### Is web scraping legal?

Web scraping publicly available information is generally permitted, but how you handle and utilize the data matters:

- **Personal data:** If your collection includes personal information, ensure compliance with relevant privacy regulations like GDPR or CCPA.
- **Copyright:** Respect original content rights and avoid republishing protected materials without proper authorization.
- **Terms of use:** Always respect target platform guidelines, rate guidelines, and attribution requests.
- **Legal advice:** This overview is for informational purposes and does not constitute formal legal counsel.

To learn more, read Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

# Actor input Schema

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

Search Artifact Hub, or fetch one Helm chart by repository and chart name.

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

Text sent as ts_query_web on the public package search endpoint. Used in search mode.

## `kinds` (type: `array`):

Kind numbers passed as the kind query parameter. 0 is Helm charts. Other values follow Artifact Hub, for example OLM operators. Each kind is searched on its own.

## `verifiedPublisherOnly` (type: `boolean`):

When enabled, search adds verified_publisher=true so only charts from verified publishers are returned.

## `packages` (type: `array`):

Repository and chart name pairs for Helm detail mode, one repo/name per line, such as bitnami/postgresql.

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

Maximum chart records to save in one run. Hard cap is 1000.

## `requestDelaySecs` (type: `number`):

Seconds to wait between HTTP calls. The actor never goes faster than 1 request per second.

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

User-Agent sent on every request. Keep a contact address so the source can identify the client.

## `timeoutSecs` (type: `integer`):

Stop the run after this many seconds, even if the item cap is not reached.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a single HTTP response before treating that call as failed.

## `proxyConfiguration` (type: `object`):

Optional proxy settings. Default is no proxy. Turn on Apify Proxy or supply your own proxy URLs if you need another IP.

## Actor input object example

```json
{
  "mode": "search",
  "query": "postgres",
  "kinds": [
    0
  ],
  "verifiedPublisherOnly": false,
  "packages": [
    "bitnami/postgresql"
  ],
  "maxItems": 100,
  "requestDelaySecs": 1,
  "userAgent": "",
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Full dataset for this run.

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

Table of chart name, version, stars, and source URL.

# 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 = {
    "query": "postgres",
    "kinds": [
        0
    ],
    "packages": [
        "bitnami/postgresql"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_lead_generation/artifact-hub-helm-charts-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 = {
    "query": "postgres",
    "kinds": [0],
    "packages": ["bitnami/postgresql"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_lead_generation/artifact-hub-helm-charts-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 '{
  "query": "postgres",
  "kinds": [
    0
  ],
  "packages": [
    "bitnami/postgresql"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call b2b_lead_generation/artifact-hub-helm-charts-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,b2b_lead_generation/artifact-hub-helm-charts-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/BN2SHQ1kFCQjyrQSg/builds/nIRLGi8npsVZAgcPX/openapi.json