# Pulumi Registry Scraper (`crawlergang/pulumi-registry-scraper`) Actor

Scrape the Pulumi Registry - search packages/providers or fetch details by name. Returns version, publisher, category, download stats, repo URLs, and package metadata for all 300+ Pulumi packages.

- **URL**: https://apify.com/crawlergang/pulumi-registry-scraper.md
- **Developed by:** [Crawler Gang](https://apify.com/crawlergang) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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 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

## Pulumi Registry Scraper

Search and extract data from the [Pulumi Registry](https://www.pulumi.com/registry/) — the official package repository for Pulumi infrastructure-as-code providers and components. Retrieve package details, publisher information, version histories, categories, and repository URLs for all 300+ published Pulumi packages without any authentication.

### What Does This Actor Do?

This actor scrapes the public Pulumi Registry API to help you:

- **Discover Pulumi packages** across all categories — cloud, database, infrastructure, monitoring, network, and utility
- **Search for providers** covering AWS, Azure, Google Cloud, Kubernetes, Datadog, Cloudflare, and hundreds more
- **Fetch specific packages** by exact name for direct metadata lookup
- **Track package versions** and see the latest published versions of any provider
- **Identify native vs bridged providers** and understand how packages are built
- **Monitor the Pulumi ecosystem** with all 300+ packages accessible in one run

### Output Data

Each record contains fields such as:

| Field | Description |
|---|---|
| `name` | Package slug (e.g. `aws`, `azure-native`, `kubernetes`) |
| `title` | Human-readable package title (e.g. `AWS`, `Azure Native`) |
| `publisher` | Publisher account slug |
| `publisherDisplayName` | Publisher display name |
| `version` | Latest published version |
| `description` | Short description of what the package provides |
| `category` | Package category: `cloud`, `database`, `infrastructure`, `monitoring`, `network`, or `utility` |
| `repoUrl` | Source code repository URL |
| `sourceUrl` | Canonical Pulumi Registry URL for this package |
| `packageTypes` | Package type(s): `bridged`, `native`, or `component` |
| `packageStatus` | Release status: `ga`, `public_preview`, or `beta` |
| `source` | Source ecosystem (e.g. `pulumi`, `opentofu`) |
| `isFeatured` | Whether the package is featured on the registry homepage |
| `createdAt` | ISO 8601 timestamp of package creation |
| `recordType` | Always `package` |
| `scrapedAt` | ISO 8601 timestamp of when the record was scraped |

### Input Configuration

#### Mode

| Mode | Description |
|---|---|
| `search` | Browse and filter all Pulumi packages with optional query/category filters |
| `getByName` | Fetch specific packages by exact name (e.g. `aws`, `azure-native`) |

#### Input Fields

| Field | Type | Description |
|---|---|---|
| `mode` | string (required) | Scraping mode (`search` or `getByName`) |
| `query` | string | Substring search across name, title, description, and publisher |
| `category` | string | Filter by category: `cloud`, `database`, `infrastructure`, `monitoring`, `network`, `security`, `utility` |
| `names` | array of strings | Exact package names to fetch (mode=getByName only) |
| `maxItems` | integer | Maximum records to return (1–10000, default: 100) |

### Example Inputs

#### Search for AWS-related packages

```json
{
  "mode": "search",
  "query": "aws",
  "maxItems": 50
}
```

#### Browse all cloud category packages

```json
{
  "mode": "search",
  "category": "cloud",
  "maxItems": 200
}
```

#### Get specific packages by name

```json
{
  "mode": "getByName",
  "names": ["aws", "azure-native", "kubernetes", "gcp", "datadog"]
}
```

#### Browse all monitoring packages

```json
{
  "mode": "search",
  "category": "monitoring",
  "maxItems": 100
}
```

#### Get all packages (no filters)

```json
{
  "mode": "search",
  "maxItems": 500
}
```

### Use Cases

- **Platform engineering** — Inventory all available Pulumi providers for your organization's approved stack
- **IaC ecosystem research** — Analyze the Pulumi package ecosystem, publisher breakdown, and category distribution
- **Developer tooling** — Build internal portals and package browsers for teams adopting Pulumi
- **Version monitoring** — Track the latest versions of providers you depend on
- **Migration planning** — Identify bridged vs native providers when planning Terraform-to-Pulumi migrations
- **Market intelligence** — Understand which cloud and SaaS providers have first-class Pulumi support

### FAQ

**Do I need a Pulumi account?**
No. The Pulumi Registry API is fully public and requires no authentication.

**How many packages are available?**
The Pulumi Registry currently lists 300+ packages. Setting `maxItems` to 500+ will return all of them.

**What is a bridged vs native provider?**

- **Bridged**: A Pulumi provider wrapping an existing Terraform provider
- **Native**: A provider built natively for Pulumi using the Pulumi SDK
- **Component**: A higher-level component library built on top of other providers

**Can I search by publisher?**
Yes, the `query` field searches across publisher names too, so you can search for `pulumi`, `hashicorp`, `datadog`, etc.

**What package statuses exist?**

- `ga`: Generally Available — production-ready
- `public_preview`: Public preview — stable but may have breaking changes
- `beta`: Beta — may have breaking changes

**Can I get all packages at once?**
Yes, set `mode: search` with no query/category filters and `maxItems: 1000` to get the full registry.

# Actor input Schema

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

Select what to fetch from the Pulumi Registry.

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

Filter packages by name, title, or description (mode=search only). Case-insensitive substring match.

## `category` (type: `string`):

Filter packages by category (mode=search only).

## `names` (type: `array`):

Exact Pulumi package names to fetch (e.g. \["aws", "azure-native", "kubernetes"]). Used only in getByName mode.

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

Maximum number of records to return.

## Actor input object example

```json
{
  "mode": "search",
  "query": "aws",
  "category": "",
  "maxItems": 100
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing all scraped Pulumi packages.

# 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 = {
    "mode": "search",
    "query": "aws",
    "category": "",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlergang/pulumi-registry-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 = {
    "mode": "search",
    "query": "aws",
    "category": "",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlergang/pulumi-registry-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 '{
  "mode": "search",
  "query": "aws",
  "category": "",
  "maxItems": 100
}' |
apify call crawlergang/pulumi-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/vlVbGROYVhGUbQBYO/builds/xE27Ah06cVnS8qCOz/openapi.json