# Pulumi Registry Scraper (`crawlerbros/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/crawlerbros/pulumi-registry-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

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

## 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("crawlerbros/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("crawlerbros/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 crawlerbros/pulumi-registry-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pulumi Registry Scraper",
        "description": "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.",
        "version": "1.0",
        "x-build-id": "peRfTLEBn9HRl8fDO"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~pulumi-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-pulumi-registry-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/crawlerbros~pulumi-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-pulumi-registry-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/crawlerbros~pulumi-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-pulumi-registry-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "getByName"
                        ],
                        "type": "string",
                        "description": "Select what to fetch from the Pulumi Registry.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Filter packages by name, title, or description (mode=search only). Case-insensitive substring match."
                    },
                    "category": {
                        "title": "Category filter",
                        "enum": [
                            "",
                            "cloud",
                            "database",
                            "infrastructure",
                            "monitoring",
                            "network",
                            "security",
                            "utility"
                        ],
                        "type": "string",
                        "description": "Filter packages by category (mode=search only).",
                        "default": ""
                    },
                    "names": {
                        "title": "Package names (mode=getByName)",
                        "type": "array",
                        "description": "Exact Pulumi package names to fetch (e.g. [\"aws\", \"azure-native\", \"kubernetes\"]). Used only in getByName mode.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of records to return.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
