# CodeCanyon Item Scraper (`crawlerbros/codecanyon-scraper`) Actor

Scrape CodeCanyon (Envato Market) for scripts, plugins, themes, and code items. Search by keyword, browse by category, get top sellers, new releases, or enrich specific item URLs. Returns price, sales count, ratings, author info, tags, compatibility, and more

- **URL**: https://apify.com/crawlerbros/codecanyon-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, E-commerce, Automation
- **Stats:** 1 total users, 0 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

## CodeCanyon Item Scraper

Extract script, plugin, and code item data from CodeCanyon (Envato Market) — prices, sales counts, ratings, author info, tags, compatibility details, and more.

### What You Can Scrape

- **Search results** — find items by keyword across all or specific categories
- **Category browsing** — browse PHP Scripts, WordPress, JavaScript, eCommerce, Mobile, and more
- **Top sellers** — most popular selling items in any category
- **New releases** — newest items added to any category
- **Individual items** — enrich specific CodeCanyon item URLs with full details
- **Pricing** — current item price in USD
- **Sales & ratings** — total sales count, star rating, number of reviews
- **Author info** — author name, profile URL, total lifetime sales
- **Metadata** — tags, last update date, publish date, compatible software versions, file type, file size
- **Preview availability** — whether a live demo is available

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `mode` | Select | `search` | `search` — keyword search; `byCategory` — browse a category; `topSellers` — popular items; `newReleases` — newest items; `byItemUrls` — scrape specific URLs |
| `searchQuery` | Text | `wordpress plugin` | Keywords to search (used in search mode) |
| `category` | Select | `php` | Category: PHP Scripts, WordPress, JavaScript, CSS & Design, HTML Templates, Mobile, Plugins, Forms, eCommerce, Social Networking, Utilities, Components & Libraries, Miscellaneous |
| `sortBy` | Select | `sales` | Sort order: Best Sellers, Top Rated, Newest First, Price Lowest, Price Highest, Relevance |
| `minPrice` | Integer | — | Minimum item price in USD |
| `maxPrice` | Integer | — | Maximum item price in USD |
| `startUrls` | List | — | CodeCanyon item URLs for `byItemUrls` mode |
| `maxItems` | Integer | `50` | Maximum number of items to return (1–5000) |

### Output

Each record in the dataset contains:

| Field | Type | Description |
|-------|------|-------------|
| `itemId` | String | CodeCanyon item ID |
| `title` | String | Item title |
| `url` | String | Full CodeCanyon item URL |
| `thumbnailUrl` | String | Item thumbnail image URL |
| `previewUrl` | String | Live preview URL (if available) |
| `price` | Float | Item price in USD |
| `salesCount` | Integer | Total number of sales |
| `rating` | Float | Average star rating (0–5) |
| `ratingCount` | Integer | Number of ratings/reviews |
| `author` | String | Author username |
| `authorUrl` | String | Author profile URL |
| `authorSales` | Integer | Author's total lifetime sales |
| `category` | String | Item category |
| `tags` | List | Item tags |
| `description` | String | Short item description |
| `lastUpdate` | String | Date of last update |
| `publishDate` | String | Date item was published |
| `compatibleWith` | List | Compatible software (e.g., "PHP 7.4+", "MySQL 5.6+") |
| `fileType` | String | File type (e.g., "PHP", "JavaScript") |
| `fileSize` | String | Download file size |
| `hasLiveDemo` | Boolean | Whether a live preview is available |
| `recordType` | String | Always `"codeCanyon Item"` |
| `scrapedAt` | String | ISO 8601 timestamp when scraped |

### Example Output

```json
{
  "itemId": "812145",
  "title": "Slider Revolution Responsive WordPress Plugin",
  "url": "https://codecanyon.net/item/slider-revolution/812145",
  "thumbnailUrl": "https://i.envato.com/images/slider-thumb.jpg",
  "previewUrl": "https://slider-revolution.net/",
  "price": 29.0,
  "salesCount": 890000,
  "rating": 4.52,
  "ratingCount": 12500,
  "author": "ThemePunch",
  "authorUrl": "https://codecanyon.net/user/themepunch",
  "authorSales": 1200000,
  "category": "WordPress",
  "tags": ["slider", "wordpress", "responsive", "jquery"],
  "description": "Slider Revolution is an innovative, responsive WordPress Slider Plugin.",
  "lastUpdate": "2024-01-15",
  "publishDate": "2012-06-21",
  "compatibleWith": ["WordPress 5.0+", "PHP 7.2+"],
  "fileType": "PHP",
  "fileSize": "18 MB",
  "hasLiveDemo": true,
  "recordType": "codeCanyon Item",
  "scrapedAt": "2026-05-15T10:30:00+00:00"
}
````

### FAQ

**Q: What categories can I search?**
A: CodeCanyon covers PHP Scripts, WordPress plugins/themes, JavaScript, CSS & Design, HTML Templates, Mobile apps, Plugins/Extensions, Forms, eCommerce, Social Networking, Utilities, Components & Libraries, and Miscellaneous.

**Q: What's the difference between topSellers and byCategory?**
A: `topSellers` returns the all-time bestselling items in a category sorted by total sales. `byCategory` lets you browse a category with your chosen sort order (e.g., newest, highest rated, price).

**Q: Can I search for free items?**
A: Set `maxPrice` to `0` to find free items. Note that CodeCanyon has very few free items — most are paid.

**Q: How many items can I scrape?**
A: Up to 5,000 items per run using `maxItems`. CodeCanyon paginates at ~15 items per page.

**Q: Can I scrape a specific item I found on CodeCanyon?**
A: Yes, set `mode` to `byItemUrls` and add the item URLs (like `https://codecanyon.net/item/slider-revolution/812145`) to `startUrls`.

**Q: How reliable are the sales counts?**
A: Sales counts are scraped from the item listings as shown publicly on CodeCanyon. Very high numbers (like 800,000+) are rounded/abbreviated on the site; the scraper extracts the displayed value.

**Q: What data is available on category pages vs. search results?**
A: Search results, category pages, top sellers, and new releases all return similar card-level data (title, price, sales, rating, author). Individual item pages (`byItemUrls`) provide additional detail like compatible software, file size, tags, and live preview links.

**Q: Does the scraper require authentication?**
A: No. All scraped data is publicly visible on CodeCanyon without login.

# Actor input Schema

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

What to scrape: search by keyword, browse a category, get top sellers, new releases, or enrich specific item URLs.

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

Keyword(s) to search for (used in search mode). Example: 'wordpress plugin', 'payment gateway', 'slider'.

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

Filter by category (used in search, byCategory, topSellers, and newReleases modes).

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

Sort order for search and category results.

## `minPrice` (type: `integer`):

Minimum item price in USD.

## `maxPrice` (type: `integer`):

Maximum item price in USD.

## `startUrls` (type: `array`):

Specific CodeCanyon item URLs to scrape (used in byItemUrls mode). Example: https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737

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

Maximum number of items to return.

## Actor input object example

```json
{
  "mode": "topSellers",
  "searchQuery": "wordpress plugin",
  "category": "wordpress",
  "sortBy": "sales",
  "startUrls": [
    "https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737"
  ],
  "maxItems": 50
}
```

# Actor output Schema

## `items` (type: `string`):

Dataset containing all scraped CodeCanyon items.

# 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": "topSellers",
    "searchQuery": "wordpress plugin",
    "category": "wordpress",
    "sortBy": "sales",
    "startUrls": [
        "https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/codecanyon-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": "topSellers",
    "searchQuery": "wordpress plugin",
    "category": "wordpress",
    "sortBy": "sales",
    "startUrls": ["https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/codecanyon-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": "topSellers",
  "searchQuery": "wordpress plugin",
  "category": "wordpress",
  "sortBy": "sales",
  "startUrls": [
    "https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737"
  ],
  "maxItems": 50
}' |
apify call crawlerbros/codecanyon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CodeCanyon Item Scraper",
        "description": "Scrape CodeCanyon (Envato Market) for scripts, plugins, themes, and code items. Search by keyword, browse by category, get top sellers, new releases, or enrich specific item URLs. Returns price, sales count, ratings, author info, tags, compatibility, and more",
        "version": "1.0",
        "x-build-id": "KB9NwhLhmKUhnmYDv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~codecanyon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-codecanyon-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~codecanyon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-codecanyon-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~codecanyon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-codecanyon-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": {
                    "mode": {
                        "title": "Scraping Mode",
                        "enum": [
                            "search",
                            "byCategory",
                            "topSellers",
                            "newReleases",
                            "byItemUrls"
                        ],
                        "type": "string",
                        "description": "What to scrape: search by keyword, browse a category, get top sellers, new releases, or enrich specific item URLs.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword(s) to search for (used in search mode). Example: 'wordpress plugin', 'payment gateway', 'slider'."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "php",
                            "wordpress",
                            "javascript",
                            "css",
                            "html-templates",
                            "mobile",
                            "plugins",
                            "forms",
                            "ecommerce",
                            "social-networking",
                            "utilities",
                            "components",
                            "miscellaneous"
                        ],
                        "type": "string",
                        "description": "Filter by category (used in search, byCategory, topSellers, and newReleases modes).",
                        "default": "php"
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "sales",
                            "rating",
                            "date-added",
                            "price-asc",
                            "price-desc",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort order for search and category results.",
                        "default": "sales"
                    },
                    "minPrice": {
                        "title": "Minimum Price ($)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Minimum item price in USD."
                    },
                    "maxPrice": {
                        "title": "Maximum Price ($)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum item price in USD."
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Specific CodeCanyon item URLs to scrape (used in byItemUrls mode). Example: https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of items to return.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
