# GitHub Marketplace Scraper (`crawlerbros/github-marketplace-scraper`) Actor

Scrape GitHub Marketplace apps, integrations, and Actions. Search by keyword, browse by category, or fetch specific listings by slug. Extracts name, description, pricing, categories, publisher info, and more

- **URL**: https://apify.com/crawlerbros/github-marketplace-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 7 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 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

## GitHub Marketplace Scraper

Extract app listings, integrations, and GitHub Actions from [GitHub Marketplace](https://github.com/marketplace) — without any API authentication. Get names, descriptions, pricing plans, categories, publisher details, and more.

### What It Does

- **Search apps & integrations** — find tools by keyword across all GitHub Marketplace apps
- **Search GitHub Actions** — discover automation actions by name or category
- **Browse by category** — explore all listings within a specific marketplace category
- **Fetch by slug** — retrieve detailed information for specific listings by their URL slug

### Input Schema

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `mode` | select | Scraping mode: `searchApps`, `searchActions`, `byCategory`, `bySlug` | `searchApps` |
| `searchQuery` | text | Keyword to search for (searchApps and searchActions modes) | `code review` |
| `category` | select | Category filter: `api-management`, `code-quality`, `security`, etc. | — |
| `planType` | select | Filter by pricing: `all`, `free`, `paid`, `free_trials` | `all` |
| `sortBy` | select | Sort results: `best-match`, `most-installed`, `newest` | `best-match` |
| `slugs` | string list | List of slugs to fetch (bySlug mode only) | — |
| `maxItems` | integer | Maximum number of results to return (1–1000) | `50` |

#### Available Categories

| Value | Label |
|-------|-------|
| `api-management` | API Management |
| `chat` | Chat |
| `code-quality` | Code Quality |
| `code-review` | Code Review |
| `continuous-integration` | Continuous Integration |
| `dependency-management` | Dependency Management |
| `deployment` | Deployment |
| `ides` | IDEs |
| `learning` | Learning |
| `monitoring` | Monitoring |
| `project-management` | Project Management |
| `publishing` | Publishing |
| `recently-added` | Recently Added |
| `security` | Security |
| `support` | Support |
| `testing` | Testing |
| `utilities` | Utilities |

### Output Schema

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | integer | Internal GitHub listing ID |
| `slug` | string | URL slug identifier (e.g., `dependabot`) |
| `name` | string | Display name of the app/action |
| `shortDescription` | string | Short summary of what the tool does |
| `fullDescription` | string | Detailed description |
| `url` | string | Full GitHub Marketplace URL |
| `logoUrl` | string | URL to the listing logo/icon |
| `planType` | string | Pricing model: `free`, `paid`, or `free_trials` |
| `pricing` | array | Pricing plan details (name, price, features) |
| `categories` | array | Category slugs the listing belongs to |
| `rating` | float | Average user rating |
| `installedCount` | integer | Number of installations |
| `verifiedPublisher` | boolean | Whether the publisher is GitHub-verified |
| `publisherName` | string | Name of the publisher/developer |
| `publisherUrl` | string | Publisher's GitHub profile URL |
| `recordType` | string | Always `githubMarketplaceListing` |
| `scrapedAt` | string | ISO 8601 timestamp of when the record was scraped |

#### Pricing Plan Fields

Each item in the `pricing` array contains:

| Field | Type | Description |
|-------|------|-------------|
| `name` | string | Plan name (e.g., "Free", "Pro", "Enterprise") |
| `monthlyPriceInCents` | integer | Monthly price in US cents (0 = free) |
| `yearlyPriceInCents` | integer | Annual price in US cents |
| `description` | string | Plan description |
| `bullets` | array | Feature list for this plan |

### Example Output

```json
{
  "slug": "github-actions",
  "name": "GitHub Actions",
  "shortDescription": "Automate your workflow from idea to production",
  "url": "https://github.com/marketplace/github-actions",
  "planType": "free",
  "categories": ["continuous-integration", "deployment"],
  "verifiedPublisher": true,
  "publisherName": "GitHub",
  "publisherUrl": "https://github.com/github",
  "recordType": "githubMarketplaceListing",
  "scrapedAt": "2026-05-15T10:00:00+00:00"
}
````

### FAQ

**Do I need a GitHub API token to use this?**
No. The scraper accesses publicly available GitHub Marketplace pages without requiring any authentication or API keys.

**What's the difference between apps and actions?**
GitHub Marketplace hosts two types of tools: *apps* (integrations that connect to your repositories and organizations) and *actions* (reusable workflow steps for GitHub Actions pipelines). Use `searchApps` for apps/integrations and `searchActions` for workflow actions.

**Can I filter apps by price?**
Yes. Use the `planType` filter to show only free apps, paid apps, or apps with free trials available.

**How many results can I get?**
The `maxItems` field supports up to 1,000 listings per run. GitHub Marketplace paginates results, so the scraper automatically fetches multiple pages as needed.

**Can I scrape a specific app's details?**
Yes. Use `mode=bySlug` and provide the listing slug (the part after `/marketplace/` in the URL). For example, `dependabot` for `https://github.com/marketplace/dependabot`.

**What data is available for each listing?**
The scraper extracts all publicly visible metadata: name, description, pricing, categories, publisher information, installation count, ratings, and verification status.

**Why might some fields be missing?**
The scraper only outputs fields that contain actual data. If a listing doesn't have a rating, installation count, or certain pricing details, those fields are omitted rather than returned as null.

**How do I find the right category slug?**
Category slugs match the URL parameters on GitHub Marketplace. For example, browsing `https://github.com/marketplace?type=apps&category=security` corresponds to the `security` category.

# Actor input Schema

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

What to scrape from GitHub Marketplace.

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

Keyword to search for (used in searchApps and searchActions modes).

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

Filter by marketplace category (used in byCategory and search modes).

## `planType` (type: `string`):

Filter listings by pricing model.

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

How to sort the results.

## `slugs` (type: `array`):

List of marketplace listing slugs to fetch (e.g. 'github-actions', 'dependabot'). Used in bySlug mode.

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

Maximum number of listings to scrape.

## Actor input object example

```json
{
  "mode": "searchApps",
  "searchQuery": "code review",
  "planType": "all",
  "sortBy": "best-match",
  "slugs": [],
  "maxItems": 50
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped GitHub Marketplace listings.

# 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": "searchApps",
    "searchQuery": "code review",
    "planType": "all",
    "sortBy": "best-match",
    "slugs": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/github-marketplace-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": "searchApps",
    "searchQuery": "code review",
    "planType": "all",
    "sortBy": "best-match",
    "slugs": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/github-marketplace-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": "searchApps",
  "searchQuery": "code review",
  "planType": "all",
  "sortBy": "best-match",
  "slugs": [],
  "maxItems": 50
}' |
apify call crawlerbros/github-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GitHub Marketplace Scraper",
        "description": "Scrape GitHub Marketplace apps, integrations, and Actions. Search by keyword, browse by category, or fetch specific listings by slug. Extracts name, description, pricing, categories, publisher info, and more",
        "version": "1.0",
        "x-build-id": "neQSmgUE1VJv3fZ6V"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~github-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-github-marketplace-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~github-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-github-marketplace-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~github-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-github-marketplace-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": [
                            "searchApps",
                            "searchActions",
                            "byCategory",
                            "bySlug"
                        ],
                        "type": "string",
                        "description": "What to scrape from GitHub Marketplace.",
                        "default": "searchApps"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search for (used in searchApps and searchActions modes).",
                        "default": "code review"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "api-management",
                            "chat",
                            "code-quality",
                            "code-review",
                            "continuous-integration",
                            "dependency-management",
                            "deployment",
                            "ides",
                            "learning",
                            "monitoring",
                            "project-management",
                            "publishing",
                            "recently-added",
                            "security",
                            "support",
                            "testing",
                            "utilities"
                        ],
                        "type": "string",
                        "description": "Filter by marketplace category (used in byCategory and search modes)."
                    },
                    "planType": {
                        "title": "Plan type",
                        "enum": [
                            "all",
                            "free",
                            "paid",
                            "free_trials"
                        ],
                        "type": "string",
                        "description": "Filter listings by pricing model.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "best-match",
                            "most-installed",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to sort the results.",
                        "default": "best-match"
                    },
                    "slugs": {
                        "title": "Slugs (mode=bySlug)",
                        "type": "array",
                        "description": "List of marketplace listing slugs to fetch (e.g. 'github-actions', 'dependabot'). Used in bySlug mode.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of listings to scrape.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
