# Atlassian Marketplace Category Monitor (`crawlerbros/atlassian-marketplace-category-monitor`) Actor

Monitor Atlassian Marketplace app rankings by category. Lists apps sorted by install count with rank position, ideal for tracking which apps lead each category over time.

- **URL**: https://apify.com/crawlerbros/atlassian-marketplace-category-monitor.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, 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

## Atlassian Marketplace Category Monitor

Monitor which apps dominate every category on the Atlassian Marketplace. This scraper lists all apps within a chosen category ranked by install count (the default API sort order) — ideal for competitive analysis, category benchmarking, and tracking rank changes over time.

### What it does

- Browses any of the 37 Atlassian Marketplace categories
- Returns apps sorted by install count with a `rankInCategory` position field
- Filters by hosting type (Cloud, Server, Data Center, or All)
- Optionally filters by minimum average rating
- Extracts name, vendor, tagline, rating, review count, install count, pricing model, categories, addon URL, and logo

### Input

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `category` | Select | Yes | `Project management` | Atlassian Marketplace category to browse |
| `hosting` | Select | No | `cloud` | Hosting filter: `cloud`, `server`, `datacenter`, or `all` |
| `maxItems` | Integer | No | `50` | Maximum number of addons to return (1–500) |
| `minRating` | Float | No | — | Only include addons rated at or above this value (0.0–5.0) |

#### Available categories

Admin tools, Blueprints, Build management, Charts & diagramming, Code quality, Code review, Continuous integration, CRM, Custom fields, Dashboard gadgets, Dependency management, Deployments, Design tools, Document management, Documentation, Email, IDE, Integrations, IT & helpdesk, Language packs, Macros, Messaging, Mobile, Monitoring, Project management, Reports, Repository connectors, Repository hooks, Security, Shared workflows, Source code, Tasks, Testing & QA, Themes & styles, Time tracking, Utilities, Workflow

#### Example input

```json
{
  "category": "Project management",
  "hosting": "cloud",
  "maxItems": 50
}
````

### Output

Each record represents one Atlassian Marketplace addon. Example record:

```json
{
  "rankInCategory": 1,
  "addonKey": "com.pyxis.greenhopper.jira",
  "name": "Jira Software",
  "tagLine": "Plan, track, and release great software",
  "vendorName": "Atlassian",
  "categories": ["Project management", "Agile"],
  "rating": 3.85,
  "reviewCount": 1200,
  "installCount": 85000,
  "pricingModel": "Paid",
  "hosting": ["cloud"],
  "addonUrl": "https://marketplace.atlassian.com/apps/1211580/jira-software",
  "logoUrl": "https://marketplace.atlassian.com/product-listing/files/abc123.png",
  "status": "public",
  "lastUpdated": "2026-05-14T00:00:00.000+00:00",
  "scrapedAt": "2026-05-20T12:00:00+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `rankInCategory` | Integer | 1-based rank by install count within the category |
| `addonKey` | String | Unique addon identifier (e.g., `com.vendor.addon`) |
| `name` | String | Display name of the addon |
| `tagLine` | String | Short marketing tagline |
| `summary` | String | Longer description |
| `vendorName` | String | Name of the vendor/publisher |
| `categories` | Array | All categories this addon belongs to |
| `rating` | Float | Average star rating (1.0–5.0) |
| `reviewCount` | Integer | Number of reviews |
| `installCount` | Integer | Total install count |
| `pricingModel` | String | `Free` or `Paid` |
| `hosting` | Array | Hosting types: `cloud`, `server`, `datacenter` |
| `addonUrl` | String | URL to the addon's Marketplace page |
| `logoUrl` | String | URL to the addon's logo image |
| `status` | String | Addon status (e.g., `public`) |
| `lastUpdated` | String | ISO-8601 timestamp of last modification |
| `scrapedAt` | String | ISO-8601 timestamp when data was scraped |

### Use cases

- **Competitive analysis**: See which apps rank at the top of any category
- **Market research**: Track install counts and ratings across all Project Management or Workflow tools
- **Trend monitoring**: Run on a schedule to detect rank changes over time
- **Vendor benchmarking**: Compare your app's position against competitors in the same category

### FAQ

**How often does the ranking change?**
Rankings reflect the live Atlassian Marketplace API which updates frequently. Run this scraper on a schedule to capture ranking changes over time.

**Why does `pricingModel` sometimes not appear?**
Pricing information requires an additional API call per addon to fetch the version details. It is populated for all addons; if missing, the addon has no published versions yet.

**What does `rankInCategory` represent?**
It is the 1-based position of the addon in the category as returned by the Atlassian Marketplace API, which sorts by total install count (most-installed first).

**Can I get data for multiple categories in one run?**
Run separate instances for each category you want to monitor.

**What is the difference between `server` and `datacenter` hosting?**
`server` refers to self-hosted Jira/Confluence Server instances. `datacenter` refers to the Atlassian Data Center tier. `cloud` is the Atlassian-hosted SaaS offering.

**Are free-plan-only results possible?**
Yes — set `minRating: 0.0` and leave `pricingModel` unset. Use the `hosting: "cloud"` default for the most accurate free-tier results.

### Data source

Data is fetched from the public [Atlassian Marketplace REST API v2](https://marketplace.atlassian.com/docs/). No authentication, cookies, or proxy is required.

# Actor input Schema

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

Atlassian Marketplace category to browse.

## `hosting` (type: `string`):

Filter by hosting type. Choose 'all' to include all hosting types.

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

Maximum number of addons to return (1–500).

## `minRating` (type: `number`):

Only include addons with an average rating at or above this value (0.0–5.0). Leave empty to include all.

## Actor input object example

```json
{
  "category": "Project management",
  "hosting": "cloud",
  "maxItems": 50
}
```

# Actor output Schema

## `addons` (type: `string`):

Dataset containing all scraped addon records with rank, install count, rating, and metadata.

# 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 = {
    "category": "Project management",
    "hosting": "cloud",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/atlassian-marketplace-category-monitor").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 = {
    "category": "Project management",
    "hosting": "cloud",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/atlassian-marketplace-category-monitor").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 '{
  "category": "Project management",
  "hosting": "cloud",
  "maxItems": 50
}' |
apify call crawlerbros/atlassian-marketplace-category-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Atlassian Marketplace Category Monitor",
        "description": "Monitor Atlassian Marketplace app rankings by category. Lists apps sorted by install count with rank position, ideal for tracking which apps lead each category over time.",
        "version": "1.0",
        "x-build-id": "fiuBeESqnZ1wqJfeb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~atlassian-marketplace-category-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-atlassian-marketplace-category-monitor",
                "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~atlassian-marketplace-category-monitor/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-atlassian-marketplace-category-monitor",
                "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~atlassian-marketplace-category-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-atlassian-marketplace-category-monitor",
                "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": [
                    "category"
                ],
                "properties": {
                    "category": {
                        "title": "Category",
                        "enum": [
                            "Admin tools",
                            "Blueprints",
                            "Build management",
                            "Charts & diagramming",
                            "Code quality",
                            "Code review",
                            "Continuous integration",
                            "CRM",
                            "Custom fields",
                            "Dashboard gadgets",
                            "Dependency management",
                            "Deployments",
                            "Design tools",
                            "Document management",
                            "Documentation",
                            "Email",
                            "IDE",
                            "Integrations",
                            "IT & helpdesk",
                            "Language packs",
                            "Macros",
                            "Messaging",
                            "Mobile",
                            "Monitoring",
                            "Project management",
                            "Reports",
                            "Repository connectors",
                            "Repository hooks",
                            "Security",
                            "Shared workflows",
                            "Source code",
                            "Tasks",
                            "Testing & QA",
                            "Themes & styles",
                            "Time tracking",
                            "Utilities",
                            "Workflow"
                        ],
                        "type": "string",
                        "description": "Atlassian Marketplace category to browse.",
                        "default": "Project management"
                    },
                    "hosting": {
                        "title": "Hosting",
                        "enum": [
                            "cloud",
                            "server",
                            "datacenter",
                            "all"
                        ],
                        "type": "string",
                        "description": "Filter by hosting type. Choose 'all' to include all hosting types.",
                        "default": "cloud"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of addons to return (1–500).",
                        "default": 50
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Only include addons with an average rating at or above this value (0.0–5.0). Leave empty to include all."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
