# CodeCanyon Scraper (`maximedupre/codecanyon-scraper`) Actor

Scrape CodeCanyon items from searches, categories, top sellers, new releases, or item URLs. Get prices, sales, ratings, authors, categories, media URLs, and source-visible item details.

- **URL**: https://apify.com/maximedupre/codecanyon-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.70 / 1,000 scraped items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 scraper for Envato Market item data

CodeCanyon Scraper collects public item data from [CodeCanyon](https://codecanyon.net/), the Envato Market marketplace for scripts, plugins, app templates, and code items. Use it to scrape CodeCanyon search results, category pages, top sellers, new releases, or specific item URLs into a clean Apify dataset.

The Actor saves one row per CodeCanyon item. Rows can include item IDs, titles, URLs, prices, sales counts, ratings, authors, categories, thumbnail and preview URLs, source rank, scrape time, and richer item-page details such as tags, descriptions, compatibility, file metadata, publish dates, update dates, and live-preview availability when CodeCanyon shows them.

No CodeCanyon login, cookies, API key, or Envato account is required from you. For a quick first run, keep the prefilled `wordpress plugin` search, leave the category on `WordPress`, and start with the default item limit.

### ✅ What this Actor does

This CodeCanyon scraper is built for marketplace research, product research, plugin research, competitor tracking, and Envato Market reporting. It supports the main public ways people browse CodeCanyon:

- Search CodeCanyon by keyword.
- Browse a CodeCanyon category.
- Collect top sellers in a category.
- Collect new releases in a category.
- Enrich one or more known CodeCanyon item URLs.
- Filter saved items by visible USD price.
- Choose source ordering for search and category browsing.
- Cap the number of saved items per run.

Search, category, top-seller, and new-release modes return the data visible on CodeCanyon listing cards. Item URL mode opens direct item pages and returns the richest source-visible details for those items.

The Actor focuses on public marketplace metadata. It does not download paid files, access buyer accounts, scrape private Envato data, or return WordPress.org plugin data.

### 📦 Data you can extract

Each dataset row is one CodeCanyon item. Fields can include:

- `itemId` - stable CodeCanyon item ID.
- `title` - item title.
- `url` - canonical CodeCanyon item URL.
- `thumbnailUrl` and `previewUrl` - source-visible media and live-preview links.
- `price`, `priceText`, and `currency` - visible item price data.
- `salesCount` and `salesCountText` - sales data, including the displayed source text.
- `rating`, `ratingCount`, and `ratingCountText` - rating data when visible.
- `author` and `authorUrl` - seller name and public author page.
- `category` - visible CodeCanyon category.
- `tags`, `description`, `lastUpdate`, `publishDate`, `compatibleWith`, `fileType`, `fileSize`, and `hasLiveDemo` - richer item details when the source page exposes them.
- `sourceMode`, `sourceQuery`, `sourceCategory`, `sourceUrl`, and `sourcePosition` - context for where the item came from.
- `recordType`, `scrapedAt`, and `status` - row type, scrape time, and success status.

Some fields can be empty. CodeCanyon listing pages usually show card-level data, while direct item pages expose more detail.

### 🧭 Common use cases

- Track CodeCanyon top sellers in a category.
- Monitor new CodeCanyon releases for a niche.
- Build a list of WordPress plugins, PHP scripts, JavaScript tools, or mobile app templates.
- Compare item prices, sales counts, ratings, and authors.
- Enrich known item URLs before product research or competitive analysis.
- Export marketplace rows to CSV, JSON, Excel, Google Sheets, webhooks, or your own API workflow.
- Schedule repeat runs on Apify to watch a category over time.

### 🚀 How to run

1. Choose **What to collect**.
2. For **Search results**, enter a `Search query`.
3. For **Item URLs**, paste one or more CodeCanyon item URLs.
4. For category-based modes, choose a `Category`.
5. Choose `Sort by` for search or category browsing.
6. Add optional price filters if you only want items in a price range.
7. Set `Maximum items`, run the Actor, and open the dataset.

For a first test, use the default search input and a small item limit. Raise the limit after the output shape looks right for your workflow.

### ⚙️ Input options

| Field | What it does |
| --- | --- |
| `mode` | Selects search, category browsing, top sellers, new releases, or item URL mode. |
| `searchQuery` | Keyword used when `mode` is `search`. |
| `startUrls` | CodeCanyon item URLs used when `mode` is `byItemUrls`. |
| `category` | CodeCanyon category used by search, category, top-seller, and new-release modes. |
| `sortBy` | Source order for search and category browsing. |
| `minPrice` | Saves only items at or above this visible USD price. |
| `maxPrice` | Saves only items at or below this visible USD price. |
| `maxItems` | Maximum number of item rows to save. |

### ✍️ Input examples

Search CodeCanyon for WordPress plugins:

```json
{
	"mode": "search",
	"searchQuery": "wordpress plugin",
	"category": "wordpress",
	"sortBy": "sales",
	"maxItems": 200
}
````

Enrich a known item URL:

```json
{
	"mode": "byItemUrls",
	"startUrls": [
		{
			"url": "https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737"
		}
	],
	"maxItems": 1
}
```

### 📄 Output example

```json
{
	"itemId": "242431",
	"title": "WPBakery Page Builder for WordPress",
	"url": "https://codecanyon.net/item/wpbakery-page-builder-for-wordpress/242431",
	"price": 99,
	"priceText": "$99",
	"currency": "USD",
	"salesCountText": "407.6K Sales",
	"author": "wpbakery",
	"category": "Utilities",
	"sourceMode": "search",
	"sourceQuery": "wordpress plugin",
	"sourcePosition": 1,
	"recordType": "listing",
	"status": "ok"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You are charged for each successfully scraped CodeCanyon item. Invalid inputs, empty results, and source pages that do not produce an item row are not saved as dataset rows.

### ⚠️ Limits and notes

- CodeCanyon can show different fields on listing pages and item pages.
- Listing modes are best for market scans and rankings.
- Item URL mode is best when you need richer details for known items.
- Visible sales counts can be rounded or abbreviated by CodeCanyon. The Actor keeps the displayed text so you can preserve the source precision.
- The Actor collects public marketplace metadata only. It does not download purchased files or access private account data.

### ❓ FAQ

#### Do I need a CodeCanyon account?

No. The Actor collects public CodeCanyon marketplace pages and does not ask for CodeCanyon cookies, login details, or an Envato API key.

#### Why are some rich fields empty in search results?

Search and category pages expose listing-card data. For richer fields such as tags, longer descriptions, compatibility, and file metadata, use **Item URLs** mode with direct CodeCanyon item pages.

#### Can I scrape top sellers and new releases?

Yes. Choose **Top sellers** or **New releases**, pick a category, and set the item limit for the run.

#### Can I export the data?

Yes. You can export the Apify dataset as JSON, CSV, Excel, XML, RSS, or HTML, or consume the rows through the Apify API.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~codecanyon-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Allegro Scraper ↗](https://apify.com/maximedupre/allegro-scraper) - scrape ecommerce product listings, prices, sellers, and delivery data from Allegro.
- [Mercado Libre Search Scraper ↗](https://apify.com/maximedupre/mercado-libre-search-scraper) - collect product search rows from Mercado Libre and Mercado Livre.
- [Etsy Keywords Research Tool ↗](https://apify.com/maximedupre/etsy-keywords-research-tool) - collect Etsy autocomplete keyword ideas for ecommerce SEO research.
- [Pinterest Keyword Scraper ↗](https://apify.com/maximedupre/pinterest-keyword-scraper) - export Pinterest autocomplete suggestions for content and keyword research.
- [App Store Ratings Scraper ↗](https://apify.com/maximedupre/app-store-ratings-scraper) - monitor public app ratings, review counts, and app store metadata.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Choose the CodeCanyon source for this run.

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

Use this when `What to collect` is `Search results`.

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

Use this when `What to collect` is `Item URLs`. Direct item pages return the richest item details.

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

Category used for search, browsing, top sellers, and new releases.

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

Order used for search and category browsing.

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

Only save items at or above this visible USD price.

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

Only save items at or below this visible USD price.

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

Maximum CodeCanyon item rows to save for the run.

## Actor input object example

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

# Actor output Schema

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

Open the dataset with collected 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 = {
    "searchQuery": "wordpress plugin",
    "startUrls": [
        {
            "url": "https://codecanyon.net/item/perfex-powerful-open-source-crm/14013737"
        }
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CodeCanyon Scraper",
        "description": "Scrape CodeCanyon items from searches, categories, top sellers, new releases, or item URLs. Get prices, sales, ratings, authors, categories, media URLs, and source-visible item details.",
        "version": "0.1",
        "x-build-id": "oPsYsH4ka6m4Rs21e"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~codecanyon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-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/maximedupre~codecanyon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-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/maximedupre~codecanyon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-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": "What to collect",
                        "enum": [
                            "search",
                            "byCategory",
                            "topSellers",
                            "newReleases",
                            "byItemUrls"
                        ],
                        "type": "string",
                        "description": "Choose the CodeCanyon source for this run.",
                        "default": "search"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Use this when `What to collect` is `Search results`."
                    },
                    "startUrls": {
                        "title": "CodeCanyon item URLs",
                        "type": "array",
                        "description": "Use this when `What to collect` is `Item URLs`. Direct item pages return the richest item details.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "A CodeCanyon item URL.",
                                    "pattern": "^https?://"
                                }
                            }
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "php",
                            "wordpress",
                            "javascript",
                            "css",
                            "html5",
                            "mobile",
                            "plugins"
                        ],
                        "type": "string",
                        "description": "Category used for search, browsing, top sellers, and new releases.",
                        "default": "wordpress"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "sales",
                            "rating",
                            "date-added",
                            "price-asc",
                            "price-desc",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Order used for search and category browsing.",
                        "default": "sales"
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Only save items at or above this visible USD price."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Only save items at or below this visible USD price."
                    },
                    "maxItems": {
                        "title": "Maximum items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum CodeCanyon item rows to save for the run.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
