# GitHub Marketplace App & Action Listings by Category (`nimbryxo-studio/github-marketplace-app-and-action-listings`) Actor

Search GitHub Marketplace apps and Actions by keyword, browse an entire category, or fetch listings by slug. Returns pricing plans, categories, publisher verification and install counts.

- **URL**: https://apify.com/nimbryxo-studio/github-marketplace-app-and-action-listings.md
- **Developed by:** [Nimbryxo-studio](https://apify.com/nimbryxo-studio) (community)
- **Categories:** Developer tools, Automation, Integrations
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/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

## GitHub Marketplace Apps & Actions Listing Collector

Collect structured data on GitHub Marketplace apps, integrations and GitHub Actions without a GitHub account, OAuth token or API key. Search by keyword, browse any of the 34 marketplace categories, or look up exact listings by slug or URL.

### What this actor does

- **Search apps and integrations** by keyword across the whole marketplace
- **Search GitHub Actions** as a separate listing type
- **Search both at once** and get the two types interleaved by marketplace rank
- **Browse a category** — 34 real marketplace categories, for apps or Actions
- **Look up exact listings** by slug, marketplace path or full URL; app and Action forms are detected automatically
- **Filter by pricing** — free trial (server-side), has a free plan, has a paid plan
- **Filter by verified creator** — only listings from GitHub-verified publishers
- **Filter by publisher login, minimum installs or minimum Action stars**
- **Sort by best match, popularity/installs or recently added**
- **Paginate to the marketplace's own limits** — 20 listings per page, up to your `maxItems`

Every record is built from the marketplace's own embedded JSON, not from marketing HTML, so pricing plans, install counts, publisher details, permissions and Action repository stats are exact values rather than guesses.

### Output per listing

Common fields:

- `listingId`, `listingType` (`app` or `action`), `slug`, `name`, `shortDescription`
- `fullDescription`, `extendedDescription` — plain text converted from the listing HTML
- `url`, `sourceUrl`, `logoUrl`, `rank` (1-based position in the result stream), `searchQuery`, `searchCategory`
- `categories` (slugs) and `categoryNames` (display names)
- `planType`, `hasFreePlan`, `hasPaidPlan`, `hasFreeTrial`, `freeTrialLength`, `isBuyable`
- `pricing[]` — plan name, description, monthly/yearly price in cents, formatted price, per-unit flag, unit name, free-trial flag, paid flag, bullets and plan ID
- `installedCount` (apps), `stars` (Actions)
- `verifiedPublisher`, `publisherName`, `publisherLogin`, `publisherUrl`, `publisherAvatarUrl`, `publisherType`
- `brandColor`, `documentationUrl`, `privacyPolicyUrl`, `tosUrl`, `statusUrl`, `supportUrl`, `supportEmail`, `pricingUrl`
- `recordType` (always `githubMarketplaceListing`), `scrapedAt` (ISO-8601 UTC)

App-specific fields:

- `businessId`, `euTrader`, `traderAddress`, `publisher2faRequired`, `transparencyDisclosure`
- `thirdPartyServices` (GitHub's own declaration; it can literally be `None` when the publisher declares no third-party services), `verifiedDomain`, `verifiedProfileDomains`, `supportedLanguages`
- `permissions[]` — scope, permission level and the granted values
- `repositoryUrl`, `repositoryVisibility`, `listableType`, `isCopilotApp`

Action-specific fields:

- `usesRef` — the `owner/repo@` prefix used in workflow files
- `repository` — name, owner, URL, third-party/organization flags, contributor count, open issues and pull requests, issues/security-policy/discussions flags
- `latestRelease` and `releases[]` — tag name, release name and pre-release flag

Empty fields are omitted rather than returned as `null` or a blank value.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `searchApps` | `searchApps`, `searchActions`, `searchAll`, `byCategory` or `bySlug` |
| `searchQuery` | text | empty | Keyword for the search modes; leave empty to browse popular listings |
| `category` | select | — | One of 34 marketplace categories (mode=byCategory or as a search filter) |
| `categoryType` | select | `apps` | `apps` or `actions` when browsing a category |
| `planType` | select | `all` | `all`, `free`, `paid` or `free_trials` |
| `verifiedOnly` | boolean | `false` | Only GitHub-verified creators |
| `sortBy` | select | `best-match` | `best-match`, `most-installed` or `newest` |
| `owners` | string list | `[]` | Keep only these publisher logins |
| `minInstalls` | integer | `0` | Minimum install count (apps) |
| `minStars` | integer | `0` | Minimum repository stars (Actions) |
| `slugs` | string list | `[]` | Slugs, paths or URLs for mode=bySlug |
| `maxItems` | integer | `50` | Maximum listings to save (1–1000) |

#### Example: search for code-review apps with a free trial

```json
{
  "mode": "searchApps",
  "searchQuery": "code review",
  "planType": "free_trials",
  "verifiedOnly": true,
  "sortBy": "most-installed",
  "maxItems": 50
}
```

#### Example: browse the security category for Actions

```json
{
  "mode": "byCategory",
  "category": "security",
  "categoryType": "actions",
  "sortBy": "newest",
  "maxItems": 50
}
```

#### Example: apps and Actions together

```json
{
  "mode": "searchAll",
  "searchQuery": "deploy to aws",
  "maxItems": 40
}
```

#### Example: exact listings by slug or URL

```json
{
  "mode": "bySlug",
  "slugs": [
    "codecov",
    "github-pages",
    "https://github.com/marketplace/actions/checkout",
    "https://github.com/marketplace/snyk"
  ]
}
```

#### Example: only large apps from one publisher

```json
{
  "mode": "searchApps",
  "searchQuery": "monitoring",
  "owners": ["datadog"],
  "minInstalls": 1000,
  "maxItems": 20
}
```

### Use cases

- **DevOps tooling research** — compare CI/CD, deployment and monitoring integrations before adding one to a pipeline
- **Vendor and market mapping** — catalog every listing in a category, with install counts and pricing tiers
- **Pricing benchmarking** — collect monthly/yearly and per-seat prices, free plans and trial lengths in one dataset
- **Action due diligence** — compare Action stars, latest releases, contributors and open issue counts
- **Publisher tracking** — filter a search or category down to specific GitHub accounts
- **Link collection** — resolve a list of slugs or URLs into canonical marketplace records

### FAQ

**Do I need a GitHub account, token or proxy?** No. The actor reads public GitHub Marketplace pages with no authentication, cookies or proxy configuration.

**Why are install counts exact for apps but Actions use stars?** GitHub Marketplace publishes an installation count on app listings. Action listings publish the source repository's star count instead; the actor returns whichever metric the listing actually has.

**How does pricing filtering work?** `free_trials` uses GitHub's own free-trial filter. `free` and `paid` are checked against each listing's published plans after the detail page is read, so they are exact rather than text guesses. A listing with both a free plan and a paid plan counts as having both; `planType` reports `paid` as the primary type while `hasFreePlan` stays `true`. Actions are not sold through Marketplace billing plans, so the `free`, `paid` and `free_trials` filters return apps only; use `minStars` to filter Actions.

**Why can a narrow filter take longer?** `minInstalls`, `minStars`, `owners` and the free/paid checks are applied after each listing's detail page is read, because GitHub does not expose them as server-side filters. The actor stops after a bounded number of consecutive pages with no match rather than scanning the entire catalogue.

**Why is there no rating field?** GitHub Marketplace does not publish star ratings or review scores for listings. The actor does not invent one.

**Why are screenshots missing?** GitHub serves listing screenshots from signed URLs that expire after five minutes. Shipping them would produce broken links; the listing `url` opens the gallery instead.

**How many listings can I get?** Apps: all 1,408 currently listed. Actions: GitHub caps a single query at 500 result pages (10,000 listings); use a narrower keyword or category to reach different slices. `maxItems` is capped at 1,000 per run.

**Does it cover AI model listings?** No. GitHub Marketplace also lists AI models, but they use a different schema (no slug, model registry fields). This actor focuses on apps, integrations and Actions.

**Does it monitor changes between runs?** No. It is a stateless collector; save each dataset and compare snapshots on your side.

**Is this affiliated with GitHub?** No. It is an independent actor that reads GitHub Marketplace's public pages.

### Limitations

- No ratings or reviews (GitHub Marketplace has none).
- Screenshot URLs are signed and expire; they are not emitted.
- One Action query reaches at most 500 pages / 10,000 listings (GitHub's cap). Split by category, keyword or sort order for wider coverage.
- Support email, repository URL and some legal fields are published only for a subset of apps; they are omitted when absent.
- Action README content is not emitted; the listing `url` links to it.
- The actor does not install apps or Actions and does not access private repositories.

# Actor input Schema

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

What to collect from GitHub Marketplace.

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

Keyword to search for (mode=searchApps, searchActions, searchAll). Leave empty to browse the most popular listings.

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

Marketplace category (mode=byCategory, or as an extra filter in the search modes).

## `categoryType` (type: `string`):

Whether to browse apps or Actions in mode=byCategory.

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

Filter by pricing model. Free-trial filtering is server-side; free/paid are checked against each listing's published plans.

## `verifiedOnly` (type: `boolean`):

Only return listings from GitHub-verified creators.

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

How to order the results.

## `owners` (type: `array`):

Keep only listings published by these GitHub accounts, e.g. 'actions' or 'hashicorp'. Case-insensitive. Needs detail data, which the actor always fetches.

## `minInstalls` (type: `integer`):

Only return apps with at least this many installations. Actions have stars instead, so this filter excludes them.

## `minStars` (type: `integer`):

Only return Actions whose repository has at least this many stars. Apps have install counts instead, so this filter excludes them.

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

Listing slugs, marketplace paths or full URLs, e.g. 'codecov', 'github-pages', '/marketplace/actions/checkout' or 'https://github.com/marketplace/snyk'. Apps and Actions are detected automatically.

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

Maximum number of listings to save.

## Actor input object example

```json
{
  "mode": "searchApps",
  "searchQuery": "code review",
  "categoryType": "apps",
  "planType": "all",
  "verifiedOnly": false,
  "sortBy": "best-match",
  "owners": [],
  "minInstalls": 0,
  "minStars": 0,
  "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",
    "categoryType": "apps",
    "planType": "all",
    "verifiedOnly": false,
    "sortBy": "best-match",
    "owners": [],
    "minInstalls": 0,
    "minStars": 0,
    "slugs": [],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("nimbryxo-studio/github-marketplace-app-and-action-listings").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",
    "categoryType": "apps",
    "planType": "all",
    "verifiedOnly": False,
    "sortBy": "best-match",
    "owners": [],
    "minInstalls": 0,
    "minStars": 0,
    "slugs": [],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("nimbryxo-studio/github-marketplace-app-and-action-listings").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 '{
  "mode": "searchApps",
  "searchQuery": "code review",
  "categoryType": "apps",
  "planType": "all",
  "verifiedOnly": false,
  "sortBy": "best-match",
  "owners": [],
  "minInstalls": 0,
  "minStars": 0,
  "slugs": [],
  "maxItems": 50
}' |
apify call nimbryxo-studio/github-marketplace-app-and-action-listings --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nimbryxo-studio/github-marketplace-app-and-action-listings"
        }
    }
}
```

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/RICo17VXeE77pM3QW/builds/tlmcflGALCOnH2XeJ/openapi.json