# Jetbrains Plugins Scraper (`klondikeking/jetbrains-plugins-scraper`) Actor

- **URL**: https://apify.com/klondikeking/jetbrains-plugins-scraper.md
- **Developed by:** [Pierrick McD0nald](https://apify.com/klondikeking) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 plugin extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## JetBrains Plugins Scraper

Extract comprehensive plugin data from JetBrains Marketplace including IntelliJ IDEA, PyCharm, WebStorm, PhpStorm, Rider, GoLand, RubyMine, and CLion plugins. Get detailed metadata, ratings, download counts, compatibility information, and pricing data for market research, competitive analysis, and plugin discovery.

### Features

- **Multi-IDE Coverage**: Supports all JetBrains IDEs (IntelliJ, PyCharm, WebStorm, PhpStorm, Rider, GoLand, RubyMine, CLion)
- **Flexible Search**: Search by keyword or extract specific plugins by ID
- **Comprehensive Metadata**: Name, description, version, vendor, license, pricing model
- **Performance Metrics**: Download counts, ratings, review counts
- **Compatibility Data**: Supported IDE versions and build ranges
- **Categorization**: Tags and categories for organization
- **Update Tracking**: Publish date, last update, and changelog notes
- **PPE Pricing**: Pay only for what you extract with spending limit protection
- **Rate Limiting**: Configurable delays to respect API limits
- **Error Handling**: Robust retry logic with graceful degradation

### Use Cases

#### Plugin Market Research
Analyze the JetBrains plugin ecosystem to identify trending plugins, popular categories, and market gaps. Track download counts and ratings to understand user preferences across different IDEs.

#### Competitive Analysis
Monitor competitor plugins in your niche. Compare ratings, feature sets, pricing models, and update frequency to position your own plugin effectively in the marketplace.

#### Plugin Discovery for Teams
Find the best plugins for your development team. Search by category, compare ratings, and verify compatibility with your specific IDE versions before installation.

#### License Compliance Auditing
Extract license information for all installed plugins to ensure compliance with company policies. Identify paid vs free plugins and track commercial dependencies.

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `searchQuery` | string | No | - | Search plugins by keyword (e.g., "docker", "kubernetes", "theme") |
| `pluginIds` | string[] | No | - | List of specific plugin IDs to extract |
| `maxPlugins` | integer | No | 50 | Maximum number of plugins to extract (1-1000) |
| `sortBy` | string | No | "downloads" | Sort results by: downloads, rating, name, updated |
| `proxyConfiguration` | object | No | {useApifyProxy: false} | Proxy settings (not required for JetBrains API) |
| `delayMs` | integer | No | 500 | Delay between requests in milliseconds |

### Output Example

```json
{
  "id": "7724",
  "name": "Docker",
  "description": "Provides integration with Docker...",
  "vendor": {
    "name": "JetBrains",
    "url": "https://www.jetbrains.com"
  },
  "version": "232.8660.185",
  "downloads": 12500000,
  "rating": 4.5,
  "reviewCount": 342,
  "pricing": "Free",
  "license": "Apache 2.0",
  "categories": ["Tools Integration"],
  "tags": ["docker", "containers", "devops"],
  "compatibleWith": ["IntelliJ IDEA", "PyCharm", "WebStorm"],
  "sinceBuild": "232.0",
  "untilBuild": "232.*",
  "size": "15.2 MB",
  "url": "https://plugins.jetbrains.com/plugin/7724",
  "updateDate": "2024-01-15",
  "publishDate": "2015-06-15",
  "changeNotes": "Added support for Docker Compose...",
  "extractedAt": "2026-04-01T10:00:00.000Z"
}
````

### Pricing

This Actor uses Pay-Per-Event (PPE) pricing:

| Event | Price |
|-------|-------|
| Plugin extracted | $0.002 per plugin |

**Example costs:**

- 100 plugins = $0.20
- 500 plugins = $1.00
- 1000 plugins = $2.00

No subscription required. Pay only for what you use.

### How to Use

#### Search by Keyword

Extract popular Docker-related plugins:

```json
{
  "searchQuery": "docker",
  "maxPlugins": 20,
  "sortBy": "downloads"
}
```

#### Extract Specific Plugins

Get details for known plugin IDs:

```json
{
  "pluginIds": ["Docker", "Rainbow Brackets", "Key Promoter X"],
  "maxPlugins": 10
}
```

#### Find Highly Rated Plugins

Discover top-rated plugins in a category:

```json
{
  "searchQuery": "theme",
  "maxPlugins": 50,
  "sortBy": "rating"
}
```

### FAQ

**Q: Do I need a JetBrains account?**
A: No. This Actor uses the public JetBrains Marketplace API which requires no authentication.

**Q: What JetBrains IDEs are supported?**
A: All major IDEs: IntelliJ IDEA, PyCharm, WebStorm, PhpStorm, Rider, GoLand, RubyMine, and CLion.

**Q: How fresh is the data?**
A: Data is extracted in real-time from the JetBrains Marketplace API.

**Q: Is there a rate limit?**
A: The Actor includes configurable rate limiting (default 500ms between requests) to be respectful to the API.

### Limitations

- Maximum 1000 plugins per run (configurable)
- Plugin IDs must be valid JetBrains plugin identifiers
- Some fields may be null if not provided by the plugin author
- Historical download data is not available (only current counts)

### Support

For issues, feature requests, or questions about this Actor, please open an issue on this Actor's Apify page.

***

*Built with the JetBrains Marketplace API. This Actor is not affiliated with or endorsed by JetBrains.*

# Actor input Schema

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

Search for plugins by keyword (e.g., 'docker', 'kubernetes', 'theme')

## `pluginIds` (type: `array`):

List of specific plugin IDs to extract (optional)

## `maxPlugins` (type: `integer`):

Maximum number of plugins to extract

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

Sort results by

## `proxyConfiguration` (type: `object`):

Configure proxy settings (not required for JetBrains API)

## `delayMs` (type: `integer`):

Delay between requests in milliseconds (to be respectful)

## Actor input object example

```json
{
  "searchQuery": "docker",
  "pluginIds": [
    "Docker",
    "Kubernetes",
    "Rainbow Brackets"
  ],
  "maxPlugins": 10,
  "sortBy": "downloads",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "delayMs": 500
}
```

# Actor output Schema

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

Dataset containing all extracted plugin data

## `stats` (type: `string`):

Key-value store containing run statistics

# 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 = {
    "searchQuery": "docker",
    "pluginIds": [
        "Docker",
        "Kubernetes",
        "Rainbow Brackets"
    ],
    "maxPlugins": 10,
    "sortBy": "downloads",
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "delayMs": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("klondikeking/jetbrains-plugins-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 = {
    "searchQuery": "docker",
    "pluginIds": [
        "Docker",
        "Kubernetes",
        "Rainbow Brackets",
    ],
    "maxPlugins": 10,
    "sortBy": "downloads",
    "proxyConfiguration": { "useApifyProxy": False },
    "delayMs": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("klondikeking/jetbrains-plugins-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 '{
  "searchQuery": "docker",
  "pluginIds": [
    "Docker",
    "Kubernetes",
    "Rainbow Brackets"
  ],
  "maxPlugins": 10,
  "sortBy": "downloads",
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "delayMs": 500
}' |
apify call klondikeking/jetbrains-plugins-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jetbrains Plugins Scraper",
        "version": "1.0",
        "x-build-id": "ZQOSQ2dEEGsYUEYPb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/klondikeking~jetbrains-plugins-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-klondikeking-jetbrains-plugins-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/klondikeking~jetbrains-plugins-scraper/runs": {
            "post": {
                "operationId": "runs-sync-klondikeking-jetbrains-plugins-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/klondikeking~jetbrains-plugins-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-klondikeking-jetbrains-plugins-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",
                "properties": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for plugins by keyword (e.g., 'docker', 'kubernetes', 'theme')"
                    },
                    "pluginIds": {
                        "title": "Specific Plugin IDs",
                        "type": "array",
                        "description": "List of specific plugin IDs to extract (optional)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPlugins": {
                        "title": "Maximum Plugins",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of plugins to extract",
                        "default": 50
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "downloads",
                            "rating",
                            "name",
                            "updated"
                        ],
                        "type": "string",
                        "description": "Sort results by",
                        "default": "downloads"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings (not required for JetBrains API)",
                        "default": {
                            "useApifyProxy": false
                        }
                    },
                    "delayMs": {
                        "title": "Request Delay (ms)",
                        "minimum": 100,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between requests in milliseconds (to be respectful)",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
