# Huawei AppGallery Scraper (`automation-lab/huawei-appgallery-scraper`) Actor

📱 Extract Huawei AppGallery metadata, ratings, install signals, versions, screenshots, developer details, and visible reviews from app IDs or URLs for ASO monitoring.

- **URL**: https://apify.com/automation-lab/huawei-appgallery-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Huawei AppGallery Scraper

Extract public Huawei AppGallery app metadata, ratings, install signals, versions, screenshots, developer details, and visible reviews from app IDs or URLs.

Turn AppGallery detail pages into structured JSON, CSV, Excel, XML, or RSS without maintaining a browser crawler yourself.

### What does Huawei AppGallery Scraper do?

Huawei AppGallery Scraper opens public app detail pages and returns one complete dataset record for every requested app.

It captures the information ASO teams and app publishers monitor most often:

- 📱 app name, AppGallery ID, package name, and canonical URL
- ⭐ rating, rating count, displayed install signal, and age rating
- 🚀 version, version code, update date, and release notes
- 🖼️ icon and screenshot URLs
- 🧑‍💻 developer name, website, and privacy policy
- 💬 public comments currently visible on the app detail surface
- 🌍 localized values using your chosen AppGallery locale

Use one app for a quick lookup or submit a bounded list for a recurring competitive-intelligence workflow.

### Who is it for?

#### Mobile app publishers

Track your Huawei distribution metadata and detect changes to versions, install signals, ratings, or user feedback.

#### ASO specialists

Compare positioning, descriptions, screenshots, update cadence, and reputation signals across competing apps.

#### Product and market analysts

Build historical snapshots of public AppGallery records for dashboards, notebooks, and trend analysis.

#### Data engineers

Schedule repeat runs and send structured app records into a warehouse, spreadsheet, webhook, or automation platform.

#### Agencies and consultants

Create reproducible client reports without manually copying fields from individual AppGallery pages.

### Why use this AppGallery extractor?

Huawei AppGallery is a dynamic application. Important fields arrive through browser-side requests rather than a simple static HTML document.

This Actor handles that workflow for you:

- ✅ no Huawei login or private API credential required
- ✅ accepts both AppGallery URLs and `C`-prefixed app IDs
- ✅ normalizes useful numeric fields while retaining displayed text
- ✅ skips a broken target without losing other successful apps
- ✅ fails visibly when an entire extraction produces no usable records
- ✅ exports through every standard Apify dataset format
- ✅ supports schedules, webhooks, API calls, and MCP tools

### What data can you extract?

| Field | Description |
|---|---|
| `appId` | Huawei AppGallery ID such as `C100170981` |
| `appUrl` | Canonical public detail URL for the selected locale |
| `locale` | Locale used for this extraction |
| `name` | Public app name |
| `packageName` | Android package identifier when available |
| `shortDescription` | Compact editorial description |
| `description` | Full AppGallery introduction |
| `changelog` | Current update or release notes |
| `iconUrl` | App icon URL |
| `screenshotUrls` | Public screenshot URL array |
| `rating` | Numeric aggregate rating |
| `ratingCount` | Number of ratings shown by AppGallery |
| `installs` | Numeric install magnitude returned by AppGallery |
| `installsText` | Localized install label exactly as displayed |
| `ageRating` | Displayed age-rating label |
| `minimumAge` | Numeric minimum age when provided |
| `price` | Displayed price label, for example `Free` |
| `priceAmount` | Numeric price value when available |
| `size` | Human-readable download size |
| `sizeBytes` | Numeric app size in bytes |
| `version` | Current public version |
| `versionCode` | App version code |
| `updateDate` | Localized update date |
| `developer` | Developer or publisher name |
| `developerWebsite` | Public developer website when supplied |
| `privacyPolicyUrl` | Public privacy policy URL |
| `commentCount` | Aggregate comment count when supplied |
| `reviews` | Bounded array of visible author/date/text/rating comments |
| `scrapedAt` | ISO timestamp for the snapshot |

### How to scrape Huawei AppGallery apps

1. Open the Actor input page.
2. Paste one or more Huawei AppGallery URLs or app IDs.
3. Choose a locale such as `en_US` or `de_DE`.
4. Decide whether to include visible reviews.
5. Set the maximum reviews retained per app.
6. Click **Start**.
7. Open the dataset and export it in your preferred format.

A small prefilled example is ready to run and normally completes in well under two minutes.

### Input parameters

#### AppGallery apps

`appUrls` accepts Huawei AppGallery detail URLs. Use the separate `appIds` list for raw IDs.

Supported examples:

```text
https://appgallery.huawei.com/app/C100170981
https://appgallery.huawei.com/app/C100170981?appId=C100170981&locale=en_US
````

Raw ID input:

```json
{ "appIds": ["C100170981"] }
```

The Actor removes duplicate IDs. A run can process up to 50 apps.

#### Locale

`locale` uses `ll_CC` format:

- `en_US` — English / United States
- `de_DE` — German / Germany
- `fr_FR` — French / France
- `es_ES` — Spanish / Spain

Localized labels, dates, availability, reviews, and install text may differ by locale.

#### Visible reviews

Set `includeReviews` to `true` to retain public comments returned with the detail response.

Use `maxReviewsPerApp` from 0 to 25. This setting bounds output size; it does not promise that every app has that many visible comments.

#### Advanced timeout

`navigationTimeoutSecs` controls how long the Actor waits for the public AppGallery detail response.

Keep the default unless the source is unusually slow.

### Example input

```json
{
  "appUrls": [
    { "url": "https://appgallery.huawei.com/app/C100170981" }
  ],
  "locale": "en_US",
  "includeReviews": true,
  "maxReviewsPerApp": 3,
  "navigationTimeoutSecs": 60
}
```

### Example output

```json
{
  "appId": "C100170981",
  "appUrl": "https://appgallery.cloud.huawei.com/ag/n/app/C100170981?locale=en_US&source=appshare&subsource=C100170981",
  "locale": "en_US",
  "name": "HUAWEI Browser",
  "packageName": "com.huawei.browser",
  "rating": 3.9,
  "ratingCount": 95,
  "installs": 28453,
  "installsText": "28,453M installs",
  "ageRating": "Rated 16+",
  "price": "Free",
  "size": "169.5 MB",
  "sizeBytes": 177726791,
  "version": "16.0.9.302",
  "updateDate": "12/18/2025",
  "developer": "Aspiegel SE",
  "reviews": [
    {
      "author": "Example author",
      "date": "6/14/2026, 21:42",
      "text": "Example visible comment",
      "rating": 5
    }
  ],
  "scrapedAt": "2026-07-17T00:00:00.000Z"
}
```

Values change over time and can vary by locale. Treat the example as a shape reference, not a live guarantee.

### How much does it cost to scrape Huawei AppGallery?

This Actor uses pay-per-event pricing:

- a small one-time **Start** event covers browser startup
- one **App extracted** event is charged for every complete app record saved
- failed targets that do not produce a dataset record are not charged as extracted apps
- Apify subscription tiers receive automatic volume discounts

The final run price appears in Apify before and after execution. Platform compute is included under pay-per-event billing according to the active Actor pricing.

A one-app lookup is designed to be inexpensive. Larger scheduled monitoring jobs scale with the number of complete app records produced.

### Data quality and normalization

The Actor parses named AppGallery response sections instead of depending on their position in the page.

Numeric and displayed values are both preserved where meaning can be locale-specific. For example, use `installs` for calculations and `installsText` when presenting the exact source label.

Optional fields are omitted when Huawei does not supply them. Empty placeholder values are not invented.

### Tips for reliable AppGallery monitoring

- 🔁 Use the same locale across scheduled runs for comparable dates and labels.
- 🆔 Store app IDs as stable keys in your database.
- 🕐 Schedule daily or weekly snapshots based on how quickly your market changes.
- 💬 Keep a moderate review limit unless comments are central to your workflow.
- 📊 Compare `version`, `rating`, `ratingCount`, and `installsText` between snapshots.
- 🔗 Preserve `appUrl` so analysts can audit a record against its public source.

### Export formats

Apify datasets can be downloaded as:

- JSON
- JSONL
- CSV
- Excel
- XML
- RSS

You can filter fields, unwind data, or fetch records directly through the dataset API.

### Integrations and automation workflows

#### Google Sheets monitoring

Schedule the Actor weekly, export the latest dataset, and append version/rating snapshots to a spreadsheet used by an ASO team.

#### Slack or email release alerts

Connect a run-finished webhook to Make or Zapier. Compare the latest version with your stored version and notify a release channel when it changes.

#### Data warehouse history

Use the API client to load `appId`, rating, installs, version, and `scrapedAt` into BigQuery, Snowflake, or PostgreSQL.

#### Review triage

Send visible review text to a sentiment classifier, then route low-rating comments to a customer-experience queue.

#### Competitive dashboards

Combine recurring AppGallery snapshots with Google Play and Apple App Store data for a multi-store mobile market view.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/huawei-appgallery-scraper').call({
  appUrls: [{ url: 'https://appgallery.huawei.com/app/C100170981' }],
  locale: 'en_US',
  includeReviews: true,
  maxReviewsPerApp: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/huawei-appgallery-scraper').call(run_input={
    'appIds': ['C100170981'],
    'locale': 'en_US',
    'includeReviews': True,
    'maxReviewsPerApp': 10,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~huawei-appgallery-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "appIds": ["C100170981"],
    "locale": "en_US",
    "includeReviews": true,
    "maxReviewsPerApp": 10
  }'
```

Fetch the resulting dataset using the `defaultDatasetId` returned with the run.

### Use Huawei AppGallery Scraper with MCP

Connect the Actor to Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/huawei-appgallery-scraper"
```

For Claude Desktop, Cursor, or VS Code, add an HTTP MCP server:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/huawei-appgallery-scraper"
    }
  }
}
```

Example prompts:

- “Extract the latest version, rating, and visible reviews for AppGallery app C100170981.”
- “Compare these five Huawei AppGallery apps and return a table sorted by rating count.”
- “Check whether any monitored AppGallery app changed version since my previous dataset.”

Your MCP client still needs valid Apify authentication.

### Scheduling recurring runs

Open **Schedules** in Apify Console and create a daily, weekly, or monthly trigger.

Keep the same input for stable monitoring. Use a run-finished webhook to send the dataset ID into your next automation step.

For change detection, store the previous snapshot and compare on `appId` rather than app name.

### Limitations

- V1 is detail URL/app ID based. It does not claim keyword search or category discovery.
- Reviews are the bounded comments visible in the public detail response, not a guarantee of complete historical review coverage.
- Some fields differ by locale, country, app, or availability.
- Huawei may rename fields or change its public page implementation.
- Deleted, private, region-restricted, or invalid apps may not produce records.
- Install labels should be interpreted in the context of the displayed locale and unit.

### Is scraping Huawei AppGallery legal?

This Actor extracts information visible on public AppGallery pages without logging in.

Web scraping laws and contractual obligations vary by jurisdiction and use case. You are responsible for ensuring that your collection, retention, and use of data complies with applicable laws, Huawei terms, privacy requirements, and intellectual-property rules.

Avoid collecting more personal data than necessary. Public review author labels and text may still be personal data. Apply an appropriate retention policy and lawful basis.

This documentation is informational and is not legal advice.

### Troubleshooting

#### Why did my run say the app URL is invalid?

Use a Huawei AppGallery detail URL containing a `C`-prefixed numeric app ID, or provide the ID directly. Search pages and non-Huawei marketplace URLs are outside v1 scope.

#### Why is a field missing?

AppGallery does not expose every field for every app or locale. Optional fields are omitted rather than filled with misleading placeholders.

#### Why are there fewer reviews than requested?

`maxReviewsPerApp` is a maximum. The public detail response may expose fewer comments, and some apps expose none.

#### Why does an app work in one locale but not another?

Availability and localized metadata can vary by market. Retry with a locale where the app is publicly distributed.

#### Can I submit package names?

V1 accepts AppGallery IDs or detail URLs. Resolve package names to AppGallery IDs before calling this Actor.

### Frequently asked questions

#### Does it require a Huawei account?

No. The supported scope uses public anonymous AppGallery detail pages.

#### Can it process multiple apps?

Yes. Submit up to 50 unique app IDs or URLs in one run.

#### Does it download APK files?

No. It extracts public metadata and visible comments; it does not download or redistribute app binaries.

#### Are reviews charged separately?

No. Requested visible reviews are included inside each complete app record. The per-app event is charged once for that record.

#### Can I export to Excel?

Yes. Choose Excel from the dataset export menu or use the dataset API format parameter.

#### Can I run it on a schedule?

Yes. Apify schedules support recurring monitoring without external infrastructure.

### Related mobile app scrapers

Build a broader mobile intelligence workflow with other automation-lab Actors:

- [Google Play Store Scraper](https://apify.com/automation-lab/google-play-store-scraper)
- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper)
- [Apple App Store Reviews Scraper](https://apify.com/automation-lab/apple-app-store-reviews-scraper)
- [Microsoft Store Scraper](https://apify.com/automation-lab/microsoft-store-scraper)
- [App Store Keyword Discovery Scraper](https://apify.com/automation-lab/app-store-keyword-discovery-scraper)

Use each source-specific Actor for its own marketplace; do not treat ratings or install labels as directly equivalent across stores without normalization.

### Support

If a run fails on a public AppGallery detail URL, open an issue from the Actor page.

Include:

- the app ID or public URL
- the locale used
- whether reviews were enabled
- the run ID
- a short description of the expected field or behavior

Do not include private credentials or unrelated personal information.

# Actor input Schema

## `appUrls` (type: `array`):

Add Huawei AppGallery app URLs or IDs such as C100170981. Up to 50 apps per run.

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

Optionally add C-prefixed Huawei AppGallery IDs such as C100170981.

## `locale` (type: `string`):

Choose the AppGallery language and country in ll\_CC format.

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

Include public comments currently returned on each app detail page.

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

Keep up to this many visible comments for every app.

## `navigationTimeoutSecs` (type: `integer`):

Maximum time to wait for AppGallery's public detail response.

## Actor input object example

```json
{
  "appUrls": [
    {
      "url": "https://appgallery.huawei.com/app/C100170981?appId=C100170981&locale=en_US"
    }
  ],
  "appIds": [],
  "locale": "en_US",
  "includeReviews": true,
  "maxReviewsPerApp": 3,
  "navigationTimeoutSecs": 60
}
```

# Actor output Schema

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

No description

# 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 = {
    "appUrls": [
        {
            "url": "https://appgallery.huawei.com/app/C100170981?appId=C100170981&locale=en_US"
        }
    ],
    "appIds": [],
    "locale": "en_US",
    "includeReviews": true,
    "maxReviewsPerApp": 3,
    "navigationTimeoutSecs": 60
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/huawei-appgallery-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 = {
    "appUrls": [{ "url": "https://appgallery.huawei.com/app/C100170981?appId=C100170981&locale=en_US" }],
    "appIds": [],
    "locale": "en_US",
    "includeReviews": True,
    "maxReviewsPerApp": 3,
    "navigationTimeoutSecs": 60,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/huawei-appgallery-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 '{
  "appUrls": [
    {
      "url": "https://appgallery.huawei.com/app/C100170981?appId=C100170981&locale=en_US"
    }
  ],
  "appIds": [],
  "locale": "en_US",
  "includeReviews": true,
  "maxReviewsPerApp": 3,
  "navigationTimeoutSecs": 60
}' |
apify call automation-lab/huawei-appgallery-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Huawei AppGallery Scraper",
        "description": "📱 Extract Huawei AppGallery metadata, ratings, install signals, versions, screenshots, developer details, and visible reviews from app IDs or URLs for ASO monitoring.",
        "version": "0.1",
        "x-build-id": "nM0hqXhFWqGyXvPDf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~huawei-appgallery-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-huawei-appgallery-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/automation-lab~huawei-appgallery-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-huawei-appgallery-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/automation-lab~huawei-appgallery-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-huawei-appgallery-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": {
                    "appUrls": {
                        "title": "📱 AppGallery apps",
                        "type": "array",
                        "description": "Add Huawei AppGallery app URLs or IDs such as C100170981. Up to 50 apps per run.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "appIds": {
                        "title": "AppGallery app IDs",
                        "type": "array",
                        "description": "Optionally add C-prefixed Huawei AppGallery IDs such as C100170981.",
                        "items": {
                            "type": "string",
                            "pattern": "^C[0-9]{6,}$"
                        },
                        "default": []
                    },
                    "locale": {
                        "title": "🌍 Locale",
                        "pattern": "^[a-z]{2}_[A-Z]{2}$",
                        "type": "string",
                        "description": "Choose the AppGallery language and country in ll_CC format.",
                        "default": "en_US"
                    },
                    "includeReviews": {
                        "title": "Include visible reviews",
                        "type": "boolean",
                        "description": "Include public comments currently returned on each app detail page.",
                        "default": true
                    },
                    "maxReviewsPerApp": {
                        "title": "Maximum reviews per app",
                        "minimum": 0,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Keep up to this many visible comments for every app.",
                        "default": 10
                    },
                    "navigationTimeoutSecs": {
                        "title": "⏱️ Page timeout (seconds)",
                        "minimum": 20,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Maximum time to wait for AppGallery's public detail response.",
                        "default": 60
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```