# Ecwid App Market Pricing & Category Scraper (`vexaloom-labs/ecwid-app-market-pricing-and-category-scraper`) Actor

Scrape apps from the Ecwid (Lightspeed E-Series) App Market - name, developer, description, categories, pricing type, and icon. Browse the whole market, filter by category, or search by keyword.

- **URL**: https://apify.com/vexaloom-labs/ecwid-app-market-pricing-and-category-scraper.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** E-commerce, Automation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Ecwid App Market Apps, Ratings & Reviews Scraper

Scrape **the Ecwid App Market** — the add-on marketplace for Ecwid (Lightspeed E-Series) stores. Collect every listed app with its developer, categories, pricing, free-trial flag, logo, rating and review count, then optionally open detail pages for feature bullets, screenshots and support contacts, or pull paginated customer reviews. No login, cookies, or proxy setup.

### What this actor does

- **Five modes:** browse the whole market, filter by category or collection, search by keyword, fetch exact apps, or collect reviews.
- **Complete catalog:** reads the live listing in one request — currently 405 apps — and deduplicates by app namespace.
- **Exact categories:** all 14 marketplace categories plus the Featured, New, and Free collections.
- **Decision signals:** rating, review count, real logo URL, pricing type, and a free-trial flag on every app that has them.
- **Optional depth:** developer website, support URL and email, feature bullets, screenshots, attached reviews, and standalone review records.
- **Filters and sorting:** pricing type, free-only, minimum rating, minimum review count, and sorting by name, rating or review count.
- **Empty fields are omitted:** a field is only included when the marketplace actually provides it.

### Output per app

- `appId` — unique app namespace (for example `the-printful`)
- `name` — app title
- `tagline` — short listing description
- `description` — full listing description (HTML preserved)
- `developer` — developer or company name, when published
- `categories[]` — marketplace category names
- `pricingType` — `free`, `freemium`, or `paid`
- `pricing` — the marketplace's own pricing text, when it is more than just “Free”
- `hasFreeTrial` — true when the pricing text advertises a trial
- `rating` — average rating from 0 to 5; omitted when the app has no rating
- `reviewCount` — number of published reviews; `0` is a real value
- `url` — app page on the Ecwid marketplace
- `iconUrl` — the app's real logo URL
- `headerImageUrl` — the app's header/banner image URL
- `developerWebsite` — developer site from the detail page (when `includeDetails` is on)
- `supportUrl` — support link from the detail page (when `includeDetails` is on)
- `supportEmail` — support email from the detail page (when `includeDetails` is on)
- `features[]` — feature bullets from the detail page (when `includeDetails` is on)
- `screenshots[]` — gallery image URLs, excluding the header image (when `includeDetails` is on)
- `reviews[]` — attached reviews (when `includeReviews` is on), each with `reviewId`, `rating`, `text`, `author`, `date`
- `recordType` — always `app`
- `scrapedAt` — ISO 8601 UTC capture timestamp

### Output per review

Returned by `mode: "reviews"`, or as extra records when `emitReviewRecords` is on:

- `reviewId` — marketplace review ID
- `appId`, `appName` — the reviewed app
- `rating` — 1 to 5 stars
- `text` — review body as published
- `author` — display name shown by the marketplace
- `date` — review timestamp from the source
- `url` — the app page
- `recordType` — always `review`
- `scrapedAt` — ISO 8601 UTC capture timestamp

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `browse` | `browse` / `byCategory` / `search` / `byApp` / `reviews` |
| `category` | string | `all` | Category or collection (mode=byCategory); legacy names accepted |
| `searchQuery` | string | – | Keyword matched against name, tagline, description, developer and categories (mode=search) |
| `appIds` | array | – | Namespaces or full marketplace URLs (mode=byApp or mode=reviews) |
| `includeFreeOnly` | boolean | `false` | Keep only completely free apps; overrides `pricingType` |
| `pricingType` | string | `all` | `all` / `free` / `freemium` / `paid` |
| `minRating` | number | – | Keep apps rated at or above this value (0–5); unrated apps are excluded when set |
| `minReviewCount` | integer | – | Keep apps with at least this many reviews |
| `includeDetails` | boolean | `false` | Fetch developer website, support contact, feature bullets and screenshots per app |
| `includeReviews` | boolean | `false` | Attach reviews to app records (app modes only) |
| `maxReviewsPerApp` | integer | `10` | Review cap per app (1–100) |
| `emitReviewRecords` | boolean | `false` | Also emit one record per attached review |
| `sortBy` | string | `default` | `default` / `name` / `rating` / `reviewCount` |
| `maxItems` | integer | `100` | App-record cap in app modes; review-record cap in `reviews` mode (1–1000) |

### Examples

#### Example: top-rated apps with a meaningful review history

```json
{
  "mode": "browse",
  "minRating": 4.5,
  "minReviewCount": 10,
  "sortBy": "rating",
  "maxItems": 50
}
```

#### Example: one category with full detail enrichment

```json
{
  "mode": "byCategory",
  "category": "shipping",
  "includeDetails": true,
  "maxItems": 40
}
```

#### Example: keyword search for free inventory tools

```json
{
  "mode": "search",
  "searchQuery": "inventory",
  "includeFreeOnly": true,
  "maxItems": 30
}
```

#### Example: exact apps with reviews attached

```json
{
  "mode": "byApp",
  "appIds": [
    "the-printful",
    "https://www.ecwid.com/apps/featured/kliken-stats"
  ],
  "includeDetails": true,
  "includeReviews": true,
  "maxReviewsPerApp": 25
}
```

#### Example: review records for one app

```json
{
  "mode": "reviews",
  "appIds": ["kliken-stats"],
  "maxReviewsPerApp": 50,
  "maxItems": 50
}
```

### Use cases

- **Competitive research** — compare the apps available to Ecwid merchants across categories, pricing models and ratings.
- **App directory sites** — mirror marketplace listings with logos, ratings, review counts and screenshots.
- **Pricing analysis** — separate genuinely free apps from freemium and externally billed ones.
- **Partner and developer scouting** — find active developers and the support channels they publish.
- **Voice-of-customer research** — export paginated reviews for sentiment analysis and product-gap studies.
- **Market monitoring** — re-run on a schedule to catch new listings and changing ratings.

### FAQ

**Do I need an Ecwid account?** No. The marketplace pages and review endpoints used here are public.

**How many apps are on the market?** The live total changes as developers add and remove listings. A full `browse` run currently returns about 405 apps; the actor deduplicates by namespace and reports the real total.

**What is the difference between free, freemium and paid?** `free` means the listing is marked completely free. `freemium` covers a free tier, a free trial, free tokens, or a “Free to $X” plan. Everything else is `paid`, including externally billed apps and in-app charges. The raw marketplace pricing text is kept in `pricing` when it adds detail.

**Why does a “Free to $X” app say freemium?** Because it has a free entry point but paid tiers above it. The `hasFreeTrial` flag tells you whether the pricing text also advertises a trial.

**Why do some apps have no rating?** Ratings come from the marketplace's public review widget. Apps with no reviews, or with no review product yet, omit `rating`. A real `reviewCount: 0` is kept; apps with no review product at all omit both fields.

**How many reviews can I collect?** The source returns five reviews per page. `maxReviewsPerApp` accepts 1–100, and the actor stops at the last page or after two empty pages. The largest app currently has 225 reviews, so the 100-review cap is deliberate.

**Which categories are available?** All 14 live marketplace categories plus Featured, New, and Free. A few categories (CMS, Social Media, Shipping carriers) have no public category page, so the actor matches them exactly against each app's category list.

**Does the actor expose install counts, app versions, last-updated dates, languages, badges or structured pricing tiers?** No. The marketplace does not publish those datapoints; the actor ships the raw pricing text and the fields the source actually provides.

**Are review authors anonymized?** Sometimes. The marketplace displays some reviewers as anonymized names; the actor publishes the author name exactly as shown and does not attempt to de-anonymize it.

**Is this affiliated with Ecwid or Lightspeed?** No. This is an independent third-party actor reading publicly available marketplace pages.

# Actor input Schema

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

Browse all apps, filter by category, search by keyword, fetch exact apps, or collect reviews.

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

Marketplace category or collection (mode=byCategory). Legacy names are accepted.

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

Keyword matched against app name, tagline, description, developer and categories (mode=search).

## `appIds` (type: `array`):

App namespaces or Ecwid marketplace URLs (mode=byApp or mode=reviews).

## `includeFreeOnly` (type: `boolean`):

Keep only apps whose listing is marked completely free. Overrides pricingType.

## `pricingType` (type: `string`):

Filter by free, freemium or paid pricing.

## `minRating` (type: `number`):

Keep apps rated at or above this value (0-5). Apps without a rating are excluded when set.

## `minReviewCount` (type: `integer`):

Keep apps with at least this many reviews. Apps without a review count count as zero.

## `includeDetails` (type: `boolean`):

Fetch each app's detail page for developer website, support contact, feature bullets and screenshots.

## `includeReviews` (type: `boolean`):

Attach up to maxReviewsPerApp reviews to each app record (app modes only).

## `maxReviewsPerApp` (type: `integer`):

Review cap per app, 1-100 (includeReviews and reviews modes).

## `emitReviewRecords` (type: `boolean`):

Also emit one dataset record per review when includeReviews is on.

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

Sort app records by source order, name, rating or review count.

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

Maximum app records in app modes, or review records in reviews mode (1-1000).

## Actor input object example

```json
{
  "mode": "browse",
  "category": "all",
  "appIds": [
    "the-printful"
  ],
  "includeFreeOnly": false,
  "pricingType": "all",
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerApp": 10,
  "emitReviewRecords": false,
  "sortBy": "default",
  "maxItems": 3
}
```

# Actor output Schema

## `apps` (type: `string`):

Dataset containing scraped Ecwid App Market apps and, when requested, their reviews.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "mode": "browse",
    "category": "all",
    "appIds": [
        "the-printful"
    ],
    "includeFreeOnly": false,
    "pricingType": "all",
    "includeDetails": false,
    "includeReviews": false,
    "maxReviewsPerApp": 10,
    "emitReviewRecords": false,
    "sortBy": "default",
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/ecwid-app-market-pricing-and-category-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "mode": "browse",
    "category": "all",
    "appIds": ["the-printful"],
    "includeFreeOnly": False,
    "pricingType": "all",
    "includeDetails": False,
    "includeReviews": False,
    "maxReviewsPerApp": 10,
    "emitReviewRecords": False,
    "sortBy": "default",
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/ecwid-app-market-pricing-and-category-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "browse",
  "category": "all",
  "appIds": [
    "the-printful"
  ],
  "includeFreeOnly": false,
  "pricingType": "all",
  "includeDetails": false,
  "includeReviews": false,
  "maxReviewsPerApp": 10,
  "emitReviewRecords": false,
  "sortBy": "default",
  "maxItems": 3
}' |
apify call vexaloom-labs/ecwid-app-market-pricing-and-category-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/ecwid-app-market-pricing-and-category-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1HhF1jdDY6OOB3f9b/builds/yvjWtmKgfbyDV6FVY/openapi.json