# Xiaomi GetApps Scraper (`automation-lab/xiaomi-getapps-scraper`) Actor

📱 Extract localized Xiaomi GetApps metadata, versions, ratings, downloads, APK sizes, developer details, availability, icons, and screenshots by package ID.

- **URL**: https://apify.com/automation-lab/xiaomi-getapps-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 3 total users, 2 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Xiaomi GetApps Scraper

Extract localized Xiaomi GetApps app metadata by Android package ID or public detail URL.

Xiaomi GetApps Scraper turns Xiaomi's public app pages into structured records for ASO research, release monitoring, mobile-app catalogs, and market comparisons. Each output row preserves the requested country and language, so you can compare the same package across Xiaomi markets without manually opening pages.

- 📦 Look up apps by Android package ID.
- 🔗 Process public `global.app.mi.com/details` URLs.
- 🌍 request several Xiaomi country markets in one run.
- 🚀 Export results as JSON, CSV, Excel, XML, RSS, or through the API.
- 🔐 No Xiaomi account, API key, or browser automation is required.

### What does Xiaomi GetApps Scraper do?

The Actor requests Xiaomi GetApps detail pages and extracts their embedded app record. It returns app identity, publisher and developer data, localized descriptions, category, rating, download count, APK size, release version, update timestamp, availability regions, icons, screenshots, and the source URL.

Use it for known packages rather than broad marketplace search. Version 1 intentionally stays focused on verified detail lookup and does not claim to scrape reviews, rankings, keyword search results, or every app from a developer page.

### Who is it for?

#### ASO agencies

Compare titles, descriptions, ratings, downloads, categories, and visual assets across Xiaomi markets. Feed localized snapshots into client reporting or competitive research.

#### Mobile publishers

Monitor your Xiaomi releases by version code, update timestamp, APK size, changelog, and market availability. Schedule the Actor and compare new dataset records with the previous run.

#### App-market analysts

Build a structured OEM app-store catalog that complements Google Play and Apple App Store datasets. Preserve Xiaomi-specific developer IDs and category labels.

#### Security and catalog teams

Enrich package inventories with public publisher identity, release metadata, permission IDs, icons, screenshots, and canonical source URLs.

### Why use this Xiaomi GetApps extractor?

- ✅ **Localized records:** every row includes the requested `marketRegion` and `language`.
- ✅ **Machine-ready values:** downloads and APK size are returned as exact numbers and readable bands.
- ✅ **Safe parsing:** embedded metadata is parsed with an allowlisted syntax parser, not remote code execution.
- ✅ **Fail-closed URLs:** non-Xiaomi hosts and non-detail paths cannot bypass the product scope.
- ✅ **Batch support:** combine packages and markets with bounded concurrency.
- ✅ **Apify integrations:** schedule runs, trigger webhooks, connect cloud storage, or call from code.

### What Xiaomi GetApps data can I extract?

| Data group | Fields | Typical use |
| --- | --- | --- |
| App identity | `packageId`, `appId`, `displayName` | Catalog joins and package lookup |
| Publisher | `publisherName`, `developerId`, `developerName` | Ownership and competitor analysis |
| Content | `description`, `briefDescription`, `changeLog` | ASO and localization review |
| Classification | `categoryId`, `categoryName` | Portfolio segmentation |
| Performance | `rating`, `downloadCount`, `downloadBand` | Market traction monitoring |
| Release | `versionName`, `versionCode`, `updatedAt` | Version and release alerts |
| Binary | `apkSizeBytes`, `apkSizeFormatted` | APK footprint tracking |
| Availability | `availableRegions`, `marketRegion`, `language` | Country coverage comparisons |
| Media | `iconUrl`, `cellIconUrl`, `screenshotUrls` | Creative asset audits |
| Provenance | `sourceUrl`, `scrapedAt` | Verification and freshness |

Optional fields are omitted when Xiaomi does not expose them for a package or market. The Actor does not invent values.

### How much does it cost to scrape Xiaomi GetApps apps?

The Actor uses pay-per-event pricing. A run has a small start event and an app-record event for every saved package-and-market row. Volume tiers lower the per-record price for larger customers.

The current configuration starts at **$0.005 per run**. App-record prices use the measured, formula-derived tier curve:

| Apify tier | Price per app record |
| --- | ---: |
| Free | $0.00023622 |
| Bronze | $0.00020541 |
| Silver | $0.00016022 |
| Gold | $0.00012324 |
| Platinum | $0.000082163 |
| Diamond | $0.000057514 |

A one-app, one-market test is designed to be inexpensive, and the free platform allowance may cover small evaluations. Set `maxItems` to the number of records you actually need. One package across three markets creates up to three charged records.

### How to scrape Xiaomi GetApps in 5 steps

1. Open Xiaomi GetApps Scraper in Apify Console.
2. Add one or more Android package IDs or public Xiaomi detail URLs.
3. Choose a language and one or more two-letter market regions.
4. Set a safe `maxItems` limit and click **Start**.
5. Preview the dataset or export it to JSON, CSV, Excel, XML, or an integration.

For a first run, keep the prefilled package `com.xiaomi.mipicks`, region `ID`, and `maxItems: 1`.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `packageIds` | string\[] | sample package | Android package IDs listed on Xiaomi GetApps |
| `startUrls` | URL\[] | empty | Public `global.app.mi.com/details` URLs |
| `language` | string | `en` | Two- or three-letter localization language |
| `regions` | string\[] | `ID` | ISO two-letter Xiaomi market codes |
| `maxItems` | integer | `100` | Maximum package-market records to save |
| `maxConcurrency` | integer | `5` | Parallel detail requests, from 1 to 20 |
| `proxyConfiguration` | object | direct | Optional Apify or custom proxy routing |

At least one package ID or detail URL is required. Duplicate package IDs are removed. `maxItems` caps output combinations after package and region expansion.

### Example input

```json
{
  "packageIds": [
    "com.xiaomi.mipicks"
  ],
  "language": "en",
  "regions": ["ID", "IN", "ES"],
  "maxItems": 3,
  "maxConcurrency": 3
}
```

You can mix package IDs and URLs:

```json
{
  "packageIds": ["com.xiaomi.mipicks"],
  "startUrls": [
    {"url": "https://global.app.mi.com/details?id=com.xiaomi.mipicks"}
  ],
  "language": "zh",
  "regions": ["ID"],
  "maxItems": 1
}
```

The duplicate package is requested only once.

### Output example

```json
{
  "packageId": "com.xiaomi.mipicks",
  "appId": 440365,
  "displayName": "GetApps",
  "publisherName": "小米科技有限责公司",
  "developerId": 353200,
  "developerName": "Mi Picks",
  "categoryName": "工具",
  "rating": 4.5,
  "downloadCount": 27698633,
  "downloadBand": "27M+",
  "apkSizeBytes": 72744508,
  "apkSizeFormatted": "69 MB",
  "versionName": "602-15.6.0.2",
  "versionCode": 6021560,
  "marketRegion": "ID",
  "language": "zh",
  "availableRegions": ["ID"],
  "iconUrl": "https://sf0.market.xiaomi.com/thumbnail/AppStore/...",
  "screenshotUrls": ["https://sf0.market.xiaomi.com/thumbnail/AppStore/..."],
  "sourceUrl": "https://global.app.mi.com/details?id=com.xiaomi.mipicks&la=zh&lo=ID",
  "scrapedAt": "2026-07-20T00:00:00.000Z"
}
```

Descriptions, media arrays, permissions, release time, and change log are included when Xiaomi exposes them.

### Multi-market monitoring workflow

Provide one package and several regions to produce one row per market. Store the dataset from each scheduled run and compare records by `packageId` plus `marketRegion`.

Useful alert keys include:

- 🔔 `versionCode` changed: a new release may be available.
- 🔔 `updatedAt` changed: Xiaomi refreshed the app package.
- 🔔 `downloadBand` changed: the app crossed a visible adoption threshold.
- 🔔 `rating` moved: user sentiment may have shifted.
- 🔔 `availableRegions` changed: distribution coverage may have changed.

Apify schedules can run hourly, daily, or weekly. Use a webhook to send completed datasets to your monitoring service.

### Tips for reliable results

- Start with a package known to exist on Xiaomi GetApps.
- Use uppercase two-letter region codes such as `ID`, `IN`, `ES`, or `PH`.
- Keep concurrency near the default unless you have a large package list.
- Request only the package-market combinations you need.
- Treat missing optional fields as source variation, not zero values.
- Use a proxy only when your network cannot reach the public detail pages.
- Retain `sourceUrl` and `scrapedAt` for auditability.

### Apify integrations

#### Google Sheets or Airtable

Schedule the Actor, export each completed dataset, and upsert rows using `packageId` plus `marketRegion` as the stable key.

#### Slack or email release alerts

Trigger a webhook after a run, compare `versionCode` with the prior snapshot, and send a message only when the value changes.

#### Snowflake, BigQuery, or a data lake

Call the dataset API after each run and append records partitioned by `scrapedAt`. Numeric size and download fields are ready for analysis.

#### Zapier and Make

Use the Apify integration trigger for a finished run, then route new Xiaomi app records into CRM, reporting, or catalog workflows.

### 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/xiaomi-getapps-scraper').call({
  packageIds: ['com.xiaomi.mipicks'],
  language: 'en',
  regions: ['ID', 'IN'],
  maxItems: 2,
});

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/xiaomi-getapps-scraper").call(run_input={
    "packageIds": ["com.xiaomi.mipicks"],
    "language": "en",
    "regions": ["ID", "IN"],
    "maxItems": 2,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### cURL API example

```bash
curl "https://api.apify.com/v2/acts/automation-lab~xiaomi-getapps-scraper/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "packageIds": ["com.xiaomi.mipicks"],
    "language": "en",
    "regions": ["ID"],
    "maxItems": 1
  }'
```

Poll the returned run ID or use a webhook, then read items from the run's default dataset.

### Use Xiaomi GetApps Scraper with MCP

Connect the Actor to Claude Code:

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

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

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

Example prompts:

- “Extract the current Xiaomi GetApps version and download count for `com.xiaomi.mipicks` in Indonesia.”
- “Compare this package's Xiaomi metadata across ID, IN, and ES.”
- “Return icon and screenshot URLs for these Android package IDs.”
- “Create release-monitoring rows for my Xiaomi app catalog.”

### Data quality and limitations

The Actor reports what Xiaomi exposes on the requested public detail page at run time. Availability and localized text can vary by market. Some packages may not exist in Xiaomi GetApps, and some records may omit a publisher field, screenshots, permissions, or change log.

The exact numeric `downloadCount` comes from Xiaomi's embedded record; `downloadBand` is a readable derived value. `apkSizeFormatted` is derived from `apkSizeBytes`. These fields do not claim Google Play or Apple App Store statistics.

Search, reviews, ranking history, APK downloads, and developer enumeration are outside version 1 scope.

### Is scraping Xiaomi GetApps legal?

This Actor accesses publicly available app-detail metadata without login or private credentials. Scraping legality depends on your jurisdiction, purpose, volume, and how you use the data.

Use reasonable request rates, respect applicable laws and rights, avoid personal-data misuse, and review Xiaomi's terms for your use case. The Actor is a technical tool, not legal advice. You are responsible for lawful use of exported data.

### Frequently asked questions

#### Do I need a Xiaomi account or API key?

No. The supported detail pages are public and the Actor does not require login credentials.

#### Can it search Xiaomi GetApps by keyword?

Not in version 1. Provide known Android package IDs or Xiaomi GetApps detail URLs.

#### Why did one package-market combination fail?

The package may not be listed or available for that market, or Xiaomi may have returned a temporary error. Verify the package on `global.app.mi.com`, try a supported region, and reduce concurrency if errors persist.

#### Why are some fields missing?

Xiaomi varies metadata by package and market. Optional fields are omitted rather than replaced with fabricated values.

#### Can I scrape the same app in several countries?

Yes. Add several values to `regions`; one localized row is produced for each package-region combination, up to `maxItems`.

#### How do I avoid duplicate records?

The Actor deduplicates repeated package IDs within a run. Across scheduled runs, use `packageId`, `marketRegion`, and `scrapedAt` to identify snapshots.

#### Does the Actor download APK files?

No. It extracts public metadata only and does not download or redistribute APK binaries.

### Related app-store scrapers

- [Google Play Scraper](https://apify.com/automation-lab/google-play-scraper) — search Google Play, extract app details, and collect reviews.
- [Apple App Store Scraper](https://apify.com/automation-lab/apple-app-store-scraper) — collect Apple App Store app intelligence.

Use Xiaomi GetApps Scraper when the Xiaomi OEM marketplace is the source of truth. Combine datasets from related actors when you need cross-store coverage.

### Support

If a valid public Xiaomi GetApps detail page does not produce a record, open an issue from the Actor page and include:

- the package ID or detail URL,
- the language and region,
- the run URL,
- and the behavior you expected.

Do not include private credentials. A reproducible public example helps us investigate source changes quickly.

# Actor input Schema

## `packageIds` (type: `array`):

Enter package IDs listed on Xiaomi GetApps, for example com.xiaomi.mipicks.

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

Add global.app.mi.com/details URLs. URLs from other hosts and non-detail pages are rejected.

## `language` (type: `string`):

Use a two- or three-letter language code for localized app text, such as en, es, id, or zh.

## `regions` (type: `array`):

Enter ISO two-letter country codes supported by Xiaomi GetApps, such as ID, IN, ES, or PH.

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

Stop after this many package-and-market records. Keep the first run small to control cost.

## `maxConcurrency` (type: `integer`):

Number of Xiaomi detail pages fetched in parallel. Lower this if the source starts rate-limiting requests.

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

Optional Apify Proxy or custom proxy configuration. Direct HTTP works for the normal public detail route.

## Actor input object example

```json
{
  "packageIds": [
    "com.xiaomi.mipicks"
  ],
  "language": "en",
  "regions": [
    "ID"
  ],
  "maxItems": 1,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "packageIds": [
        "com.xiaomi.mipicks"
    ],
    "language": "en",
    "regions": [
        "ID"
    ],
    "maxItems": 1,
    "maxConcurrency": 3,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/xiaomi-getapps-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 = {
    "packageIds": ["com.xiaomi.mipicks"],
    "language": "en",
    "regions": ["ID"],
    "maxItems": 1,
    "maxConcurrency": 3,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/xiaomi-getapps-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 '{
  "packageIds": [
    "com.xiaomi.mipicks"
  ],
  "language": "en",
  "regions": [
    "ID"
  ],
  "maxItems": 1,
  "maxConcurrency": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/xiaomi-getapps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/0YOj4eBl3VUD0DbY0/builds/ooavHOh8oYFX5M4US/openapi.json