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

Search JetBrains Marketplace plugins or fetch detailed listing specs. Export clean rows with downloads, ratings, tags, and pricing directly to JSON, CSV, or Excel.

- **URL**: https://apify.com/bigibyte/jetbrains-plugins-scraper.md
- **Developed by:** [BigiByte](https://apify.com/bigibyte) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

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

## JetBrains Plugins Scraper: JetBrains IDE plugins search

JetBrains plugins scraper for the Marketplace catalog. It allows you to search for plugins or pull specific listings one by one, then save the data to download in JSON, CSV, or Excel formats.

### Use cases

- **Plugin research**: Search for specific terms (like Python or Rust) to inspect listing details, download counts, ratings, and pricing models.
- **IDE coverage**: Filter search results by specific product codes (such as PyCharm or IntelliJ IDEA) to see plugins available for a particular IDE.
- **Listing audits**: Monitor specific plugin identifiers over time to track vendor details, tags, and popularity metrics.
- **Catalog comparisons**: Run queries periodically to identify newly published tools or track changes in existing listings.
- **Team reports**: Share structured CSV or Excel exports with colleagues and stakeholders who prefer spreadsheets over raw JSON data.

### Input Configuration

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `search` | Choose `search` to search the marketplace catalog, or `plugin` to pull specific details using `pluginIds`. |
| `query` | string | `python` | Search keywords to look up plugins. |
| `products` | string | empty | Optional product code (such as `pycharm` or `idea`) to narrow results to a specific IDE. |
| `pluginIds` | string list | `631` | List of numeric plugin identifiers (one per line) used when running in `plugin` mode. |
| `maxItems` | integer | `100` | Maximum number of plugin entries to collect per run (capped at 1,000). |
| `requestDelaySecs` | number | `1` | Delay between consecutive requests in seconds. |
| `userAgent` | string | BigiByteActorResearch/1.0 | Custom User-Agent header for HTTP requests. |
| `timeoutSecs` | integer | `300` | Total maximum run time in seconds. |
| `requestTimeoutSecs` | integer | `30` | Timeout duration for individual requests. |
| `proxyConfiguration` | object | No proxy | Optional proxy setup if custom network routing is needed. |

#### Example Inputs

**Search Mode Example:**

```json
{
  "mode": "search",
  "query": "python",
  "products": "",
  "maxItems": 100,
  "requestDelaySecs": 1,
  "userAgent": "BigiByteActorResearch/1.0 (contact: research@bigibyte.com)",
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": { "useApifyProxy": false }
}

```

**Plugin Details Mode Example:**

```json
{
  "mode": "plugin",
  "pluginIds": ["631"],
  "maxItems": 10,
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": { "useApifyProxy": false }
}

```

### Extracted Data Structure

Each plugin record returned by the actor contains the following structured fields:

```json
{
  "id": 631,
  "xmlId": "Pythonid",
  "name": "Python",
  "preview": "The Python plug-in provides smart editing for Python scripts. The feature set of the plugin corresponds to PyCharm IDE with a Pro subscription.",
  "downloads": 12764003,
  "rating": 3.37,
  "pricingModel": "FREE",
  "tags": ["Programming Language"],
  "vendor": { "name": "JetBrains s.r.o.", "isVerified": true },
  "url": "[https://plugins.jetbrains.com/plugin/631-python](https://plugins.jetbrains.com/plugin/631-python)",
  "scraped_at": "2026-10-12T00:00:00+00:00"
}

```

| Field | Type | Description |
| --- | --- | --- |
| `id` | integer | Unique plugin numeric identifier. |
| `xmlId` | string | Internal marketplace XML identifier. |
| `name` | string | Name of the plugin. |
| `preview` | string | Brief description or preview text from the listing. |
| `downloads` | integer | Total download count. |
| `rating` | number | Average user rating. |
| `pricingModel` | string | Pricing model (e.g., FREE, PAID, FREEMIUM). |
| `tags` | array | Associated category tags. |
| `vendor` | object | Vendor details, including name and verification status. |
| `url` | string | Web link to the marketplace listing page. |
| `scraped_at` | string | UTC timestamp when the record was retrieved. |

If an individual item fails to download, the run does not stop. An error entry containing the failure details and message is logged into the dataset so you can inspect missing items later.

### How it works

1. Reads your input settings and validates parameters (capping `maxItems` at 1,000).
2. In `search` mode, queries the marketplace using your search term and optional IDE filters, fetching records page by page until the target item count or page end is reached.
3. In `plugin` mode, fetches details individually for each listed numeric ID.
4. Pauses between requests according to `requestDelaySecs` to maintain steady traffic, automatically retrying with exponential backoff if temporary throttling occurs.
5. Removes duplicates based on plugin IDs, streams results to the dataset, and provides regular progress updates in the run logs.

### Pricing and Usage Limits

The actor itself is free to use—you only pay for standard Apify platform runtime compute units.

Requests are processed sequentially. The default delay between requests is set to 1 second, and runs naturally conclude when `maxItems` or `timeoutSecs` limits are met.

### FAQ

**How do I export data to CSV or Excel?**
Once the run completes, navigate to the dataset tab in your Apify run dashboard. From there, you can download the dataset in JSON, CSV, Excel, XML, or HTML formats.

**What happens if a plugin ID doesn't exist?**
If a requested plugin ID is not found, an error record with a 404 status is saved to the dataset, and the actor moves on to process the remaining items.

**Can I narrow searches to a specific IDE?**
Yes. Specify the product code (such as `pycharm`, `idea`, or `clion`) in the `products` parameter. Leave it blank to search across all supported IDEs.

### Related Tools

If you plan to organize or analyze these records, performing a quick CSV cleanup or merging them with internal catalog data is usually the next step. BigiByte also builds custom scrapers for developer marketplaces and software portals whenever you need dedicated workflows.

Need a scheduled monitor, custom dataset, or tailored extraction pipeline? BigiByte builds custom scrapers and data tools: https://bigibyte.com

### Trademark Notice

JetBrains Plugins and related names, logos, and trademarks belong to their respective owners. Their use in this documentation is solely to identify the target software catalog and does not imply affiliation, sponsorship, endorsement, or partnership.

### Disclaimer

This Actor is an independent tool developed by BigiByte and is not affiliated with, endorsed by, sponsored by, or otherwise officially associated with JetBrains or its subsidiaries. All collected data is sourced from publicly visible marketplace web pages. Users are responsible for complying with all applicable terms of use and guidelines.

### Is web scraping legal?

This Actor only collects publicly available data from JetBrains Plugins without bypassing access controls. Scraping public data is generally legal, but how you use the data matters:

- **Personal data:** If the results include personal data (for example names, emails, or profile details), laws such as the GDPR in the EU and the CCPA in California may apply. Only collect and store personal data when you have a legitimate reason.
- **Copyright:** Some content (articles, images, descriptions) may be protected by copyright. Do not republish full copyrighted content without permission.
- **Terms of use:** Respect the source's terms, rate limits, and any attribution requirements.
- **Legal advice:** This is general information, not legal advice. If you're unsure, consult a lawyer.

To learn more, read Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

# Actor input Schema

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

Search the JetBrains Marketplace catalog, or fetch details for specific plugin ids.

## `queries` (type: `array`):

One or more search keywords, one per line. Each is searched separately and results are merged without duplicates. Used when mode is search.

## `products` (type: `string`):

Optional JetBrains product code filter, such as idea or pycharm. Sent as the products query parameter. Leave empty to search every IDE.

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

Numeric JetBrains plugin ids, one per line. Used when mode is plugin. Example: 631 is the Python plugin.

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

Maximum plugin rows to save in one run (across all queries). Hard cap is 1000.

## `requestDelaySecs` (type: `number`):

Seconds to wait between HTTP calls so the marketplace is not hit in a burst.

## `userAgent` (type: `string`):

User-Agent sent on every request. Include an app name and a contact address.

## `timeoutSecs` (type: `integer`):

Stop the run after this many seconds, even if the item cap is not reached.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a single HTTP response before treating that call as failed.

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

Optional proxy for marketplace requests. Off by default. Turn on Apify Proxy or your own proxy URLs only if requests are blocked.

## Actor input object example

```json
{
  "mode": "search",
  "queries": [
    "python",
    "kotlin",
    "docker"
  ],
  "products": "pycharm",
  "pluginIds": [
    "631"
  ],
  "maxItems": 100,
  "requestDelaySecs": 1,
  "userAgent": "BigiByteActorResearch/1.0 (contact: research@bigibyte.com)",
  "timeoutSecs": 300,
  "requestTimeoutSecs": 30,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with plugin rows and any error rows.

## `overview` (type: `string`):

Table view of plugin id, name, downloads, rating, and source URL.

# 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 = {
    "queries": [
        "python"
    ],
    "pluginIds": [
        "631"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bigibyte/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 = {
    "queries": ["python"],
    "pluginIds": ["631"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("bigibyte/jetbrains-plugins-scraper").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 '{
  "queries": [
    "python"
  ],
  "pluginIds": [
    "631"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call bigibyte/jetbrains-plugins-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,bigibyte/jetbrains-plugins-scraper"
        }
    }
}
```

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/SIw3QWafpxx2WoF01/builds/6mLI046McHke5nSyb/openapi.json