# Woocommerce Scraper (`simpleapi/woocommerce-scraper`) Actor

WooCommerce Scraper delivers reliable product data from WooCommerce websites. Retrieve product details, categories, prices, and images for research or automation. Designed for fast scraping and consistent structured output.

- **URL**: https://apify.com/simpleapi/woocommerce-scraper.md
- **Developed by:** [SimpleAPI](https://apify.com/simpleapi) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 12 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

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

A Woocommerce Scraper helps you quickly collect structured product data from WooCommerce-powered stores. From prices and descriptions to images and stock status, it turns publicly available product information into clean, usable data. Whether you’re a store owner, researcher, or developer, it simplifies data collection and saves valuable time.

### 🛒 What does Woocommerce Scraper do?

A Woocommerce Scraper is a powerful tool designed to collect structured product and store data from WooCommerce-powered websites. It helps users automatically gather product listings, prices, descriptions, SKUs, images, ratings, and availability without manual effort.

Whether you’re using a woocommerce scraper tool, woocommerce scraper plugin, or a woocommerce scraper chrome extension, the goal remains the same: transform scattered WooCommerce data into usable datasets.

This scraper is widely used by eCommerce sellers, analysts, researchers, and developers who need fast access to WooCommerce product data. From tracking competitor prices to building internal product catalogs, a woocommerce scraper extractor simplifies complex workflows and saves countless hours.

With support for woocommerce scraper free, woocommerce scraper python, and even woocommerce scraper github integrations, it suits both non-technical users and advanced developers alike.

* * *

### 📦 What Woocommerce Scraper can I extract?

A woocommerce web scraper allows you to collect a wide range of structured data from WooCommerce stores. Below is a clear overview of what you can extract using a woocommerce product scraper.

#### 📊 Extractable Data Table

| Data Type | Description |
| --- | --- |
| 🏷️ Product Name | Full product title as displayed on the store |
| 💰 Price | Regular price, sale price, and discounts |
| 🆔 SKU | Unique product identifiers |
| 📂 Categories | Product categories and subcategories |
| 📝 Description | Short and long product descriptions |
| 🖼️ Images | Main images and product galleries |
| ⭐ Ratings | Reviews count and average ratings |
| 📦 Stock Status | In-stock / out-of-stock availability |
| 🔗 Product URL | Direct product page links |
| 🛍️ Variations | Size, color, and other variants |

This makes woocommerce scraper products extraction extremely useful for audits, research, and content enrichment.

* * *

#### ✨ Key Features of Woocommerce Scraper

A modern woocommerce data scraper comes packed with flexible and user-friendly capabilities. Here’s what makes it stand out 👇

*   ⚡ Fast bulk extraction of thousands of WooCommerce products  
      
    
*   🧩 Works as a woocommerce scraper extension, plugin, or standalone tool  
      
    
*   🖥️ Compatible with woocommerce scraper chrome extension for browser users  
      
    
*   🧠 Smart handling of variable and grouped products  
      
    
*   🐍 Developer-friendly woocommerce scraper python support  
      
    
*   🆓 Available as woocommerce scraper free for testing and small tasks  
      
    
*   🔌 Supports wordpress & woocommerce scraper plugin environments  
      
    
*   📁 Clean export formats (JSON, CSV, Excel)  
      
    
*   🔄 Handles pagination and category-based scraping  
      
    
*   🧑‍💻 Open-source options via woocommerce scraper github  
      
    

These features make it suitable for both beginners and advanced teams managing large WooCommerce stores.

* * *

### 🧭 How to use Woocommerce Scraper

Using a woocommerce product scraper tool is simple, even for first-time users. Follow this step-by-step guide 👇

#### ✅ Step-by-Step Guide

1.  Log in to Apify  
    Create a free account or sign in to your dashboard.  
      
    
2.  Select the Actor  
    Search for Woocommerce Scraper in the Apify store.  
      
    
3.  Enter Input Data  
    Paste WooCommerce product or category URLs into the startUrls field.  
      
    
4.  Choose Options  
    Decide what data you want — prices, images, variants, or full product details.  
      
    
5.  Run the Actor  
    Click start, and the woocommerce scraper extractor begins collecting data.  
      
    
6.  Download Results  
    Export your results in JSON, CSV, or Excel format.  
      
    

This process works seamlessly with woocommerce scraper plugin, browser extensions, and API-based workflows.

* * *

### 🎯 Use Cases

A woocommerce scraper tool supports many real-world applications across industries:

*   📈 Market research – Compare pricing and product trends  
      
    
*   🛒 Competitor monitoring – Track product updates and stock changes  
      
    
*   🧑‍💻 Developers – Build apps using woocommerce scraper python  
      
    
*   📦 Dropshipping – Import products into new stores  
      
    
*   📝 Content teams – Populate catalogs and landing pages  
      
    
*   🧠 Data analysis – Create structured datasets for insights  
      
    
*   🧩 Migration projects – Move WooCommerce data to other platforms  
      
    

Whether you’re using a woocommerce product scraper free version or a premium setup, these use cases deliver immediate value.

* * *

### ⭐ Why choose us?

Our Woocommerce Scraper is built with performance, reliability, and flexibility in mind. Here’s why users trust our solution 👇

*   🛠️ Supports plugin, extension, and API-based workflows  
      
    
*   🚀 Handles small and large-scale scraping smoothly  
      
    
*   🔐 Respects site structure and public data boundaries  
      
    
*   📊 Accurate extraction of woocommerce scraper products  
      
    
*   🧑‍💼 Suitable for businesses, freelancers, and developers  
      
    
*   🆓 Try with woocommerce scraper free access  
      
    
*   🌍 Works across global WooCommerce stores  
      
    
*   🧩 Easy integration with existing systems  
      
    

From woocommerce product scraper extension to enterprise workflows, we deliver dependable results.

* * *

### 📊 How many results can you scrape with Woocommerce Scraper?

The Woocommerce Scraper is designed for scalability. Whether you’re extracting a few dozen products or tens of thousands, it adapts smoothly.

#### 🚀 Performance Highlights

*   🔢 Scrape hundreds to thousands of products per run  
      
    
*   🔄 Supports multi-category and multi-store extraction  
      
    
*   📈 Scales easily for large WooCommerce catalogs  
      
    
*   🧠 Efficient handling of variable products and pagination  
      
    
*   🧑‍💻 Ideal for woocommerce scraper python automation  
      
    
*   🛍️ Reliable for full woocommerce product scraper projects  
      
    

For small tasks, a woocommerce scraper free setup is sufficient. For large-scale operations, advanced configurations ensure consistent output without data loss.

This makes it an excellent choice for agencies, researchers, and growing eCommerce teams.

* * *

### ⚖️ Is it legal to scrape Woocommerce?

Scraping WooCommerce stores generally involves collecting publicly available data, such as product names and prices. However, legality depends on several factors:

*   📜 Website terms and conditions  
      
    
*   🔐 Respecting robots.txt guidelines  
      
    
*   🧑‍⚖️ Local data protection laws  
      
    
*   🛑 Avoiding personal or restricted information  
      
    

Using a woocommerce web scraper responsibly is key. Always ensure your usage aligns with applicable laws and ethical standards. This applies whether you’re using a woocommerce scraper plugin, extension, or script.

* * *

### 🧾 Input Parameters

#### 🔧 Example Input JSON
```json
{
  "startUrls": [
    { "url": "https://woocommerce.com" }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "limit": 100,
  "featured": false,
  "sale": false,
  "devNoStrip": false
}
````

### 📤 Output Format

#### 📦 Example Output JSON

```json
{
  "url": "https://woocommerce.com/products/example/",
  "id": 12345,
  "name": "Example Product",
  "slug": "example-product",
  "type": "simple",
  "sku": "EX-001",
  "on_sale": false,
  "prices": {
    "price": "29.99",
    "regular_price": "29.99",
    "sale_price": "0",
    "currency_code": "USD",
    "currency_symbol": "$",
    "currency_prefix": "$"
  },
  "average_rating": "4.5",
  "review_count": 10,
  "images": [...],
  "categories": [...],
  "tags": [...],
  "is_in_stock": true,
  "store": "https://woocommerce.com"
}
```

### ❓ FAQ – Woocommerce Scraper

#### 1️⃣ Is there a woocommerce scraper free version?

Yes, free options are available for small-scale scraping and testing.

#### 2️⃣ Can I use a woocommerce scraper chrome extension?

Absolutely. Browser extensions are great for quick data extraction.

#### 3️⃣ Does it support woocommerce scraper python?

Yes, developers can automate workflows using Python scripts.

#### 4️⃣ Is there a woocommerce scraper plugin for WordPress?

Yes, several plugins work directly within WordPress environments.

#### 5️⃣ Can I scrape variable products?

Yes, the scraper supports product variations like size and color.

#### 6️⃣ Is woocommerce scraper github available?

Open-source projects are available for developers who prefer customization.

#### 7️⃣ Can it scrape multiple stores at once?

Yes, you can extract data from multiple WooCommerce stores in one run.

### ✅ Conclusion

Using a Woocommerce Scraper makes working with WooCommerce product data faster, easier, and more reliable. Whether you choose a plugin, extension, or standalone tool, it supports everything from research to large-scale product extraction. With flexible options and scalable output, it’s a practical solution for modern eCommerce data needs.

# Actor input Schema

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

💡 Where do you want to Shop? (Also accepts 'url' as array of store URLs)

## `url` (type: `array`):

Alternative to startUrls: array of store URLs to scrape.

## `limit` (type: `integer`):

Number of results (per-query)

## `resource` (type: `string`):

Select resource type to scrape

## `include_variations` (type: `boolean`):

Include product variations in results

## `format` (type: `string`):

💡 Output format for Descriptions. (default: Markdown)

## `sort` (type: `string`):

Sort results by attribute

## `order` (type: `string`):

Order sort direction

## `search` (type: `string`):

💡 Limit results to those matching a string.

## `sku` (type: `string`):

💡 Limit result set to products with specific SKU(s). Use commas to separate.

## `rating` (type: `string`):

💡 Filter by product ratings. Enter comma-separated rating values (e.g., 1,2,3,4,5)

## `min_price` (type: `integer`):

Limit result set to products based on a minimum price.

## `max_price` (type: `integer`):

Limit result set to products based on a maximum price.

## `tax_class` (type: `string`):

Limit result set to products with a specific tax class.

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

Product Category ID(s) separated by comma

## `tag` (type: `string`):

Product Tag ID(s) separated by comma

## `product_type` (type: `string`):

Products assigned a specific type

## `status` (type: `string`):

Filter by product status

## `stock` (type: `string`):

Filter by stock status

## `featured` (type: `boolean`):

Featured products

## `sale` (type: `boolean`):

Products on sale

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

Choose which proxies to use. By default, no proxy is used.

## `dev_proxy_config` (type: `string`):

💡 Supported protocol: HTTP(S), SOCKS5
{http|socks5}://{user:pass}@{hostname|ip-address}:port
Example: socks5://example.com:9000

## `dev_custom_headers` (type: `string`):

💡 Additional HTTP Headers as JSON array. Example: \[{"name": "Authorization", "value": "Bearer token"}]

## `dev_custom_cookies` (type: `string`):

💡 Additional HTTP Cookies as JSON array. Example: \[{"name": "session", "value": "abc123"}]

## `dev_transform_fields` (type: `string`):

💡 Transform the resulting output. Enter comma-separated field paths.
For nested object use DOT. For example: address.streetAddress
For nested array use NUMBER (index of array element starting from index=0). For example: images.0.url

## `dev_dataset_name` (type: `string`):

💡 Save results into custom named Dataset, use mask to customize dataset name
{ACTOR} = actor name
{DATE} = date (YYYYMMDD)
{TIME} = time (HHMMSS)
This masks can be used to autogenerate Dataset Name.
example: data-{DATE}
Depending on today date the dataset name will be: data-20230603
default: data-{ACTOR}-{DATE}-{TIME}

## `dev_dataset_clear` (type: `boolean`):

Clear Dataset before insert/update.

## `dev_no_strip` (type: `boolean`):

💡 Keep/Save empty values (NULL, FALSE, empty ARRAY, empty OBJECT, empty STRING)

## `dev_fileupload` (type: `string`):

💡 Upload your file and copy & paste the URL somewhere.

## Actor input object example

```json
{
  "startUrls": [
    "https://woocommerce.com"
  ],
  "limit": 20,
  "resource": "products",
  "include_variations": false,
  "format": "md",
  "sort": "date",
  "order": "",
  "featured": false,
  "sale": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "dev_dataset_clear": false,
  "dev_no_strip": false
}
```

# 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 = {
    "startUrls": [
        "https://woocommerce.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("simpleapi/woocommerce-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 = {
    "startUrls": ["https://woocommerce.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("simpleapi/woocommerce-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 '{
  "startUrls": [
    "https://woocommerce.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call simpleapi/woocommerce-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Woocommerce Scraper",
        "description": "WooCommerce Scraper delivers reliable product data from WooCommerce websites. Retrieve product details, categories, prices, and images for research or automation. Designed for fast scraping and consistent structured output.",
        "version": "0.1",
        "x-build-id": "vKMvS2y9SiNXfWSVQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/simpleapi~woocommerce-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-simpleapi-woocommerce-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/simpleapi~woocommerce-scraper/runs": {
            "post": {
                "operationId": "runs-sync-simpleapi-woocommerce-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/simpleapi~woocommerce-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-simpleapi-woocommerce-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "❓ URL",
                        "type": "array",
                        "description": "💡 Where do you want to Shop? (Also accepts 'url' as array of store URLs)",
                        "items": {
                            "type": "string"
                        }
                    },
                    "url": {
                        "title": "URL (alternative)",
                        "type": "array",
                        "description": "Alternative to startUrls: array of store URLs to scrape.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "♾️ Limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Number of results (per-query)",
                        "default": 20
                    },
                    "resource": {
                        "title": "📁 Resource",
                        "enum": [
                            "products",
                            "categories",
                            "brands",
                            "tags",
                            "attributes",
                            "reviews",
                            "pages",
                            "posts",
                            "comments",
                            "post-categories",
                            "post-tags",
                            "users"
                        ],
                        "type": "string",
                        "description": "Select resource type to scrape",
                        "default": "products"
                    },
                    "include_variations": {
                        "title": "Include Variations",
                        "type": "boolean",
                        "description": "Include product variations in results",
                        "default": false
                    },
                    "format": {
                        "title": "Output Format",
                        "enum": [
                            "md",
                            "text",
                            "html"
                        ],
                        "type": "string",
                        "description": "💡 Output format for Descriptions. (default: Markdown)",
                        "default": "md"
                    },
                    "sort": {
                        "title": "Sorting",
                        "enum": [
                            "",
                            "date",
                            "modified",
                            "id",
                            "include",
                            "title",
                            "slug",
                            "price",
                            "popularity",
                            "rating",
                            "menu_order",
                            "comment_count"
                        ],
                        "type": "string",
                        "description": "Sort results by attribute",
                        "default": "date"
                    },
                    "order": {
                        "title": "Order",
                        "enum": [
                            "",
                            "asc",
                            "desc"
                        ],
                        "type": "string",
                        "description": "Order sort direction",
                        "default": ""
                    },
                    "search": {
                        "title": "Search",
                        "type": "string",
                        "description": "💡 Limit results to those matching a string."
                    },
                    "sku": {
                        "title": "SKU",
                        "type": "string",
                        "description": "💡 Limit result set to products with specific SKU(s). Use commas to separate."
                    },
                    "rating": {
                        "title": "Product Ratings",
                        "type": "string",
                        "description": "💡 Filter by product ratings. Enter comma-separated rating values (e.g., 1,2,3,4,5)"
                    },
                    "min_price": {
                        "title": "Price Range - Min",
                        "type": "integer",
                        "description": "Limit result set to products based on a minimum price."
                    },
                    "max_price": {
                        "title": "Price Range - Max",
                        "type": "integer",
                        "description": "Limit result set to products based on a maximum price."
                    },
                    "tax_class": {
                        "title": "Tax Class",
                        "enum": [
                            "",
                            "standard",
                            "reduced-rate",
                            "zero-rate"
                        ],
                        "type": "string",
                        "description": "Limit result set to products with a specific tax class."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Product Category ID(s) separated by comma"
                    },
                    "tag": {
                        "title": "Tag",
                        "type": "string",
                        "description": "Product Tag ID(s) separated by comma"
                    },
                    "product_type": {
                        "title": "Product Type",
                        "enum": [
                            "",
                            "simple",
                            "grouped",
                            "external",
                            "variable",
                            "wbs_bundle",
                            "variation"
                        ],
                        "type": "string",
                        "description": "Products assigned a specific type"
                    },
                    "status": {
                        "title": "Product Status",
                        "enum": [
                            "",
                            "future",
                            "trash",
                            "draft",
                            "pending",
                            "private",
                            "publish"
                        ],
                        "type": "string",
                        "description": "Filter by product status"
                    },
                    "stock": {
                        "title": "Stock Status",
                        "enum": [
                            "",
                            "instock",
                            "outofstock",
                            "onbackorder"
                        ],
                        "type": "string",
                        "description": "Filter by stock status"
                    },
                    "featured": {
                        "title": "Featured",
                        "type": "boolean",
                        "description": "Featured products",
                        "default": false
                    },
                    "sale": {
                        "title": "On Sale",
                        "type": "boolean",
                        "description": "Products on sale",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Choose which proxies to use. By default, no proxy is used."
                    },
                    "dev_proxy_config": {
                        "title": "🌐 PROXY NETWORKING",
                        "type": "string",
                        "description": "💡 Supported protocol: HTTP(S), SOCKS5\n{http|socks5}://{user:pass}@{hostname|ip-address}:port\nExample: socks5://example.com:9000"
                    },
                    "dev_custom_headers": {
                        "title": "📜 HTTP HEADERS",
                        "type": "string",
                        "description": "💡 Additional HTTP Headers as JSON array. Example: [{\"name\": \"Authorization\", \"value\": \"Bearer token\"}]"
                    },
                    "dev_custom_cookies": {
                        "title": "🍰 HTTP COOKIES",
                        "type": "string",
                        "description": "💡 Additional HTTP Cookies as JSON array. Example: [{\"name\": \"session\", \"value\": \"abc123\"}]"
                    },
                    "dev_transform_fields": {
                        "title": "♻️ CUSTOM FIELD",
                        "type": "string",
                        "description": "💡 Transform the resulting output. Enter comma-separated field paths.\nFor nested object use DOT. For example: address.streetAddress\nFor nested array use NUMBER (index of array element starting from index=0). For example: images.0.url"
                    },
                    "dev_dataset_name": {
                        "title": "📁 CUSTOM STORAGE",
                        "type": "string",
                        "description": "💡 Save results into custom named Dataset, use mask to customize dataset name\n{ACTOR} = actor name\n{DATE} = date (YYYYMMDD)\n{TIME} = time (HHMMSS)\nThis masks can be used to autogenerate Dataset Name.\nexample: data-{DATE}\nDepending on today date the dataset name will be: data-20230603\ndefault: data-{ACTOR}-{DATE}-{TIME}"
                    },
                    "dev_dataset_clear": {
                        "title": "Clear Storage",
                        "type": "boolean",
                        "description": "Clear Dataset before insert/update.",
                        "default": false
                    },
                    "dev_no_strip": {
                        "title": "Disable data cleansing",
                        "type": "boolean",
                        "description": "💡 Keep/Save empty values (NULL, FALSE, empty ARRAY, empty OBJECT, empty STRING)",
                        "default": false
                    },
                    "dev_fileupload": {
                        "title": "📁 FILE UPLOADER",
                        "type": "string",
                        "description": "💡 Upload your file and copy & paste the URL somewhere."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```