# commando Scraper (`mshopik/commando-scraper`) Actor

Scrape commando and extract data on apparel from wearcommando.com. Our commando API lets you crawl product information and pricing. The saved data can be downloaded as HTML, JSON, CSV, Excel, and XML.

- **URL**: https://apify.com/mshopik/commando-scraper.md
- **Developed by:** [Mark Carter](https://apify.com/mshopik) (community)
- **Categories:** E-commerce, Open source
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

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

### What does commando Scraper do?

This scraper creates an API for commando to enable you to extract product information and pricing from the [wearcommando.com](https://wearcommando.com) online store. 

The commando API is free to use and will let you scrape and extract e-commerce data as often as you need to. The data you extract can be downloaded in structured format so that you can use it in your own applications, spreadsheets, reports, or tools.

Scraping commando could help you identify competition, opportunities, potential leads, and useful contacts. The right data can help you with product tracking, market research, and price monitoring in the apparel category.

If you need more inspiration, check out [how scraping can help you](https://apify.com/industries/ecommerce-and-retail) get an edge over the competition and stay ahead in e-commerce.

### How much will it cost to scrape commando?

Running commando Scraper will consume platform credits. Platform credits are counted in USD and each plan includes a set amount. Check our [platform pricing](https://apify.com/pricing/actors) page for details.

The exact number of platform credits consumed will depend on the actor input settings, the type of job it performs, how often it runs, and for how long.

The best way to find out how many platform credits an actor will consume is to perform a test run. You can then review platform usage in [Billing](https://console.apify.com/billing) and figure out the best Apify subscription plan for your needs.

### How to scrape commando

[wearcommando.com](https://wearcommando.com) is built using Shopify and commando Scraper is one of our huge range of online e-commerce scrapers designed to create a universal Shopify API.

Check out our [quick start guide](https://docs.apify.com/tutorials/quick-start) to using any Apify scraper or feel free to send an email to [support@apify.com](mailto:support@apify.com) if you have any questions.

You can also watch our [video about scraping Amazon](https://www.youtube.com/watch?v=BsidLZKdYWQ) to understand more about scraping e-commerce data and how it can help your business succeed.

For more ideas, read about our [top 5 web scraping tools to help you gather retail analytics](https://blog.apify.com/top-5-web-scraping-tools-gather-retail-analytics/).

# Actor input Schema

## `maxRequestsPerCrawl` (type: `integer`):

How many items to extract from wearcommando.com
## `extendOutputFunction` (type: `string`):

Add or remove properties on the output object or omit the output returning null
## `extendScraperFunction` (type: `string`):

Advanced function that allows you to extend the default scraper functionality, allowing you to manually perform actions on the page
## `customData` (type: `object`):

Any data that you want to have available inside the Extend Output/Scraper Function
## `fetchHtml` (type: `boolean`):

If you decide to fetch the HTML of the pages, it will take twice as long. Make sure to only enable this if needed
## `maxConcurrency` (type: `integer`):

Max concurrency to use
## `maxRequestRetries` (type: `integer`):

Set the max request retries
## `debugLog` (type: `boolean`):

Enable a more verbose logging to be able to understand what's happening during the scraping

## Actor input object example

```json
{
  "maxRequestsPerCrawl": 20,
  "extendOutputFunction": "async ({ data, item, product, images, fns, name, request, variants, context, customData, input, Apify }) => {\n  return item;\n}",
  "extendScraperFunction": "async ({ fns, customData, Apify, label }) => {\n \n}",
  "customData": {},
  "fetchHtml": true,
  "maxConcurrency": 20,
  "maxRequestRetries": 3,
  "debugLog": 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 = {
    "maxRequestsPerCrawl": 20,
    "extendOutputFunction": async ({ data, item, product, images, fns, name, request, variants, context, customData, input, Apify }) => {
      return item;
    },
    "extendScraperFunction": async ({ fns, customData, Apify, label }) => {
     
    },
    "customData": {},
    "maxConcurrency": 20,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("mshopik/commando-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 = {
    "maxRequestsPerCrawl": 20,
    "extendOutputFunction": """async ({ data, item, product, images, fns, name, request, variants, context, customData, input, Apify }) => {
  return item;
}""",
    "extendScraperFunction": """async ({ fns, customData, Apify, label }) => {
 
}""",
    "customData": {},
    "maxConcurrency": 20,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("mshopik/commando-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 '{
  "maxRequestsPerCrawl": 20,
  "extendOutputFunction": "async ({ data, item, product, images, fns, name, request, variants, context, customData, input, Apify }) => {\\n  return item;\\n}",
  "extendScraperFunction": "async ({ fns, customData, Apify, label }) => {\\n \\n}",
  "customData": {},
  "maxConcurrency": 20,
  "maxRequestRetries": 3
}' |
apify call mshopik/commando-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "commando Scraper",
        "description": "Scrape commando and extract data on apparel from wearcommando.com. Our commando API lets you crawl product information and pricing. The saved data can be downloaded as HTML, JSON, CSV, Excel, and XML.",
        "version": "0.0",
        "x-build-id": "Nw2eHTNIAdTRsWlDt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mshopik~commando-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mshopik-commando-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/mshopik~commando-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mshopik-commando-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/mshopik~commando-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mshopik-commando-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": {
                    "maxRequestsPerCrawl": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "How many items to extract from wearcommando.com",
                        "default": 20
                    },
                    "extendOutputFunction": {
                        "title": "Extend Output Function",
                        "type": "string",
                        "description": "Add or remove properties on the output object or omit the output returning null",
                        "default": "async ({ data, item, product, images, fns, name, request, variants, context, customData, input, Apify }) => {\n  return item;\n}"
                    },
                    "extendScraperFunction": {
                        "title": "Extend Scraper Function",
                        "type": "string",
                        "description": "Advanced function that allows you to extend the default scraper functionality, allowing you to manually perform actions on the page",
                        "default": "async ({ fns, customData, Apify, label }) => {\n \n}"
                    },
                    "customData": {
                        "title": "Custom data",
                        "type": "object",
                        "description": "Any data that you want to have available inside the Extend Output/Scraper Function",
                        "default": {}
                    },
                    "fetchHtml": {
                        "title": "Fetch HTML",
                        "type": "boolean",
                        "description": "If you decide to fetch the HTML of the pages, it will take twice as long. Make sure to only enable this if needed",
                        "default": true
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "type": "integer",
                        "description": "Max concurrency to use",
                        "default": 20
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "type": "integer",
                        "description": "Set the max request retries",
                        "default": 3
                    },
                    "debugLog": {
                        "title": "Debug Log",
                        "type": "boolean",
                        "description": "Enable a more verbose logging to be able to understand what's happening during the scraping",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
