# iOS & Android App Review Scraper (`taroyamada/app-review-cross-platform-intelligence`) Actor

Extract user reviews from both the App Store and Google Play into one dataset. Analyze recurring complaints, flag rating drift, and generate ASO summaries.

- **URL**: https://apify.com/taroyamada/app-review-cross-platform-intelligence.md
- **Developed by:** [naoki anzai](https://apify.com/taroyamada) (community)
- **Categories:** Marketing, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## App Review Intelligence API | App Store + Google Play Summary

<!-- v37-internal-flow-boost:start -->
### After this run

Turn this Actor's output into a capped paid report with [App Release Review Regression Report](https://apify.com/taroyamada/app-release-review-regression-report?utm_source=apify_internal&utm_medium=readme_after_run&utm_campaign=v37_internal_flow&utm_content=app-review-cross-platform-intelligence__app-release-review-regression-report).
Use it when mobile product, QA, support, and app growth teams need to decide whether a public app release created review regressions that need QA or product action.

- First report: $9 / `release_review_snapshot_report`; set `maxChargeUsd` to $9.
- Deeper report: $29 / `release_regression_report`; use only when the first result needs competitor or action-depth.
- This is an internal Apify flow aid. It is not revenue proof until accounted paid usage appears.
<!-- v37-internal-flow-boost:end -->

Scrape user reviews from both the Apple App Store and Google Play simultaneously to extract critical product feedback and mobile search visibility data. Instead of running separate workflows for iOS and Android, this app review scraper unifies both storefronts into a single executive summary row. It is designed for App Store Optimization (ASO) specialists, product managers, and growth marketers who need to schedule recurring state checks on their mobile applications. Extract highly structured data directly from the stores to track overall sentiment, analyze recurring complaint themes, and catch sudden rating drift before it impacts your organic rankings.

The web crawler bypasses the manual work of stitching two massive datasets together. Every time you run the scraper, you get a clean, actionable summary that clusters user feedback into distinct themes and provides immediate recommended actions based on real user comments. You can easily schedule daily or weekly scrapes to monitor your app's performance over time, keeping a close eye on competitor updates or new feature rollouts. The extracted details include cross-platform rating averages, flagged negative reviews, theme clusters, and direct platform warnings. Stop wasting time manually browsing store pages and instantly gather the vital user feedback you need to improve your mobile visibility.

### Store Quickstart

- Start with `store-input.example.json` for the lowest-friction first run.
- Check `sample-output.example.json` for the current starter proof and the exact summary row shape buyers see first.
- Check `live-proof.example.json` for the latest live canary + contract capture on the public actor surface.
- Then use `store-input.templates.json` as the familiar Wave 1 ladder:
  - `Quickstart Baseline (Cross-Platform Summary)` — smallest useful dataset run for one product
  - `Recurring Baseline (Scheduled Summary Checks)` — same summary workflow tuned for repeat monitoring
  - `Webhook Routed Summary (Cross-Platform Alerts)` — send the same payload into Slack, Zapier, or an internal monitor once dataset output already fits
  - `App Store Only Baseline` / `Google Play Only Baseline` — actor-specific fallback lanes when only one storefront matters right now

### What first success looks like

A good first run gives you:

1. `meta.executiveSummary` — one buyer-ready brief with status, cadence, reviewed platforms, and the top complaint themes.
2. `results[]` — one shareable product row with rating drift, recurring complaints, praise themes, and recommended actions.
3. `reviewCoverage`, `warnings`, and `sourceFailures` — explicit honesty about shallow Google Play review depth or any missing storefront signal.

### Key Features

- 📱 **Cross-platform baseline** — Merge Apple App Store and Google Play public signals into one product row
- 🧠 **Theme clustering** — Group recurring complaint and praise themes into stable buckets
- 🚨 **Rating drift detection** — Flag sudden softness between long-term store ratings and current public review samples
- ⚠️ **Honest source handling** — Preserve warnings and per-platform failures instead of hiding degraded coverage
- 📡 **Dataset or webhook delivery** — Feed dashboards, Slack alerts, CRM tasks, or internal monitors

### Use Cases

| Who | Why |
|-----|-----|
| Product teams | Track recurring complaint clusters after releases without stitching two stores together manually |
| ASO teams | Compare rating softness, review themes, and storefront changes across iOS and Android |
| Support / QA | Turn public review pain points into triage queues or webhook alerts |
| Market researchers | Build consistent competitor baselines from both major app stores |

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| productName | string | prefilled | Optional label for the monitored product. If empty, the actor uses the best store title it finds. |
| country | string | `"us"` | Default ISO country code for both stores. App Store lookups and review feeds use lowercase values like us, gb, jp. |
| language | string | `"en_US"` | Google Play language code for the public page request, for example en_US. |
| appleApp | object | prefilled | Optional App Store target. Provide {"appId":"570060128"} or {"url":"https://apps.apple.com/us/app/id570060128"}. |
| googlePlayApp | object | prefilled | Optional Google Play target. Provide {"appId":"com.duolingo"} or a full play.google.com URL. |
| reviewLimitPerPlatform | integer | `20` | Maximum reviews to analyze per platform. Google Play usually exposes about 20 public review cards without deeper paginat |
| lookbackDays | integer | `180` | Prefer reviews inside this window. If a source has no matches inside the window, the actor falls back to the public samp |
| minThemeMentions | integer | `2` | Minimum complaint mentions before a theme is treated as a real cluster instead of one-off noise. |

#### Input Example

```json
{
  "productName": "Duolingo",
  "country": "us",
  "language": "en_US",
  "appleApp": {
    "appId": "570060128",
    "country": "us"
  },
  "googlePlayApp": {
    "appId": "com.duolingo",
    "country": "us",
    "language": "en_US"
  },
  "reviewLimitPerPlatform": 20,
  "lookbackDays": 180,
  "minThemeMentions": 2,
  "delivery": "dataset",
  "dryRun": false
}
````

### Input Examples

#### Example: Single app cross-platform

```json
{
  "iosAppId": "1234567890",
  "androidPackage": "com.example.app",
  "maxReviewsPerPlatform": 50
}
```

#### Example: iOS only

```json
{
  "iosAppId": "1234567890",
  "maxReviewsPerPlatform": 100
}
```

#### Example: Multi-region

```json
{
  "iosAppId": "1234567890",
  "country": "US,JP,DE",
  "maxReviewsPerPlatform": 30
}
```

### Output

| Field | Type | Description |
|-------|------|-------------|
| `meta` | object |  |
| `results` | array |  |
| `results[].productKey` | string |  |
| `results[].productName` | string |  |
| `results[].storesCovered` | array |  |
| `results[].status` | string |  |
| `results[].summary` | string |  |
| `results[].recommendedCadence` | string |  |
| `results[].reviewsAnalyzed` | number |  |
| `results[].reviewCoverage` | object |  |
| `results[].ratingDrift` | object |  |
| `results[].recommendedActions` | array |  |
| `results[].topThemes` | array |  |
| `results[].praiseThemes` | array |  |
| `results[].recurringComplaints` | array |  |
| `results[].platforms` | object |  |

#### Output Example

```json
{
  "meta": {
    "generatedAt": "2026-04-04T09:30:00.000Z",
    "warnings": [
      "Google Play public HTML exposed 4 review cards in the fixture sample; deeper pagination is intentionally disabled to keep maintenance low."
    ],
    "sourceFailures": [],
    "totals": {
      "products": 1,
      "platformsRequested": 2,
      "platformsSucceeded": 2,
      "platformsFailed": 0,
      "reviewsAnalyzed": 7,
      "recurringComplaints": 2,
      "complaintThemes": 4
    },
    "executiveSummary": {
      "overallStatus": "urgent",
      "brief": "Duolingo is showing a softer public review sample than its long-term store ratings, with monetization and stability complaints persisting across platforms.",
      "recommendedCadence": "daily",
      "reviewedPlatforms": 2,
      "totalReviewsAnalyzed": 7,
      "recurringComplaintCount": 2,
      "topComplaintThemes": [
        {
          "id": "monetization",
          "label": "Pricing, ads & paywall",
          "complaintMentions": 2,
          "platforms": [
            "appStore",
            "googlePlay"
          ]
        },
        {
          "id": "stability",
          "label": "Crashes, freezes & lost progress",
          "complaintMentions": 2,
          "platforms": [
            "appStore",
            "googlePlay"
```

### Proof buyers can inspect

| Buyer question | Proof asset | What it proves |
|----------------|-------------|----------------|
| "Will the first run already be usable in a product or growth review?" | `store-input.example.json` + `sample-output.example.json` | The quickstart returns one summary-first row with executive summary, rating drift, theme clusters, and recommended actions. |
| "Is the public actor still working live on Apify?" | `live-proof.example.json` | The latest canary + contract capture passed on the public actor surface. |
| "What is the safest way to expand without changing the output shape?" | `store-input.templates.json` | The quickstart, recurring, webhook, and single-store fallback templates keep the same summary-first lane while widening scope. |

### API Usage

Run this actor programmatically using the Apify API. Replace `YOUR_API_TOKEN` with your token from [Apify Console → Settings → Integrations](https://console.apify.com/account/integrations).

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/taroyamada~app-review-cross-platform-intelligence/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "productName": "Duolingo", "country": "us", "language": "en_US", "appleApp": { "appId": "570060128", "country": "us" }, "googlePlayApp": { "appId": "com.duolingo", "country": "us", "language": "en_US" }, "reviewLimitPerPlatform": 20, "lookbackDays": 180, "minThemeMentions": 2, "delivery": "dataset", "dryRun": false }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")
run = client.actor("taroyamada/app-review-cross-platform-intelligence").call(run_input={
  "productName": "Duolingo",
  "country": "us",
  "language": "en_US",
  "appleApp": {
    "appId": "570060128",
    "country": "us"
  },
  "googlePlayApp": {
    "appId": "com.duolingo",
    "country": "us",
    "language": "en_US"
  },
  "reviewLimitPerPlatform": 20,
  "lookbackDays": 180,
  "minThemeMentions": 2,
  "delivery": "dataset",
  "dryRun": false
})

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

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('taroyamada/app-review-cross-platform-intelligence').call({
  "productName": "Duolingo",
  "country": "us",
  "language": "en_US",
  "appleApp": {
    "appId": "570060128",
    "country": "us"
  },
  "googlePlayApp": {
    "appId": "com.duolingo",
    "country": "us",
    "language": "en_US"
  },
  "reviewLimitPerPlatform": 20,
  "lookbackDays": 180,
  "minThemeMentions": 2,
  "delivery": "dataset",
  "dryRun": false
});

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

### Tips & Limitations

- Run weekly for trend tracking; daily for competitive launch monitoring.
- Use webhook delivery to push insights into your BI tools or research Slack.
- Archive results in Apify Dataset for your own historical trend analysis.
- Combine with `ai-visibility-monitor-actor` for AI-era brand surface coverage.
- Start with a small watchlist, iterate on keyword precision before scaling.

### FAQ

**What platforms are covered?**

This actor covers public Apple App Store and Google Play storefront signals only. If you want single-store runs, use the dedicated sibling actors.

**Can I run only one platform?**

Yes. Provide only `appleApp` or only `googlePlayApp` and the actor still returns a valid single-platform summary row.

**How complete are the review samples?**

They are intentionally public-surface only. Apple can expose more review rows through RSS than Google Play, while Google Play may fall back to aggregate-only coverage.

**Can I send the summary somewhere else?**

Yes. Keep `delivery: "dataset"` for inspection or switch to `delivery: "webhook"` to push the same summary payload into Slack, Zapier, n8n, or your own endpoint.

### Related Actors

Use this actor first when you need one buyer-ready summary across iOS and Android. Add the adjacent actor only when you need the deeper layer below:

- [Apple App Store Intelligence API](https://apify.com/taroyamada/apple-app-store-intelligence) — Add after the cross-platform baseline when the iOS team needs deeper App Store review coverage, pricing checks, or storefront-specific QA.
- [Google Play Intelligence API](https://apify.com/taroyamada/google-play-intelligence) — Add when Android launches, geo tests, or Play-only warning handling need a dedicated package / country / language watchlist.
- [Shopify Store Intelligence API | Catalog & Merch Signals](https://apify.com/taroyamada/shopify-store-intelligence) — Add when the same brand also sells through Shopify and you want to connect app complaints with catalog, merchandising, or launch-page changes.
- [Shopify App Store Review Intelligence](https://apify.com/taroyamada/shopify-app-store-review-intelligence) — Add when the company also sells software to Shopify merchants and you want to compare consumer app complaints with merchant onboarding, billing, or support complaints.
- [Domain Security Audit API | SSL Expiry, DMARC & Security Headers](https://apify.com/taroyamada/domain-trust-monitor) — Add when review pain points may stem from login, billing, or checkout trust issues on the brand's owned domains.

### Pricing & Cost Control

Apify Store pricing is usage-based. This actor keeps start friction low and charges the buyer-ready app summary row:

- `apify-actor-start`: $0.00005
- `apify-default-dataset-item`: $0.015 per app summary row

The current implementation emits one dataset row per monitored app. Raw review-row pricing is reserved for a future explicit PPE event if raw review export is added.

- Start with the `Quickstart Baseline` on 1 product in dataset mode while you validate summary quality.
- Keep `reviewLimitPerPlatform` modest for the `Recurring Baseline`; raise it only when deeper complaint analysis changes decisions.
- Use the single-store variants when only one storefront matters, then move to `Webhook Routed Summary` once the downstream route is stable.
- Use `dryRun: true` before scheduled runs or webhook delivery.

### ⭐ Was this helpful?

If this actor saved you time, please [**leave a ★ rating**](https://apify.com/taroyamada/app-review-cross-platform-intelligence/reviews) on Apify Store. It takes 10 seconds, helps other developers discover it, and keeps updates free.

Bug report or feature request? Open an issue on the [Issues tab](https://apify.com/taroyamada/app-review-cross-platform-intelligence/issues) of this actor.

### Next Step: Listing Gap Report

If you need a buyer-ready listing improvement report instead of raw metadata or review rows, run `mobile-app-listing-gap-report` next. It compares one target app with competitor App Store / Google Play listings, checks buyer-provided seed keyword coverage in public metadata, and returns prioritized listing edits.

Recommended handoff:

```json
{
  "targetApp": "APP_STORE_URL_OR_GOOGLE_PLAY_PACKAGE",
  "competitorApps": ["COMPETITOR_APP_1", "COMPETITOR_APP_2", "COMPETITOR_APP_3"],
  "reportTier": "premium",
  "maxChargeUsd": 29,
  "dryRun": false
}
```

### Related report Actors

Use these follow-on Actors when you want a capped, decision-ready report instead of more raw rows. They use public or user-provided inputs, respect `maxChargeUsd`, and do not promise rankings, revenue, conversion lifts, or sales outcomes.

- [App Release Review Regression Report](https://apify.com/taroyamada/app-release-review-regression-report) - summarize public app reviews as release regressions, topic spikes, and QA backlog candidates.
- [App Store & Google Play Listing Gap Report](https://apify.com/taroyamada/mobile-app-listing-gap-report) - connect review pain points to public listing-message gaps.

### Related paid report workflows

If this Actor gave you raw rows or source context, these follow-on report Actors are designed for a small capped paid run. They help make a decision, not just collect more data.

- [App Release Review Regression Report](https://apify.com/taroyamada/app-release-review-regression-report) - decide whether a public app release created review regressions that need QA or product action. Entry $9 / `release_review_snapshot_report`; premium $29 / `release_regression_report`.
- [App Store & Google Play Listing Gap Report](https://apify.com/taroyamada/mobile-app-listing-gap-report) - decide which app listing metadata and positioning gaps to fix before spending on paid acquisition. Entry $9 / `listing_snapshot_checklist`; premium $29 / `competitor_listing_gap_report`.

Keep `maxChargeUsd` equal to the selected tier. Internal links are traffic aids only; real proof requires accounted paid usage.

# Actor input Schema

## `productName` (type: `string`):

Optional label for the monitored product. If empty, the actor uses the best store title it finds.

## `country` (type: `string`):

Default ISO country code for both stores. App Store lookups and review feeds use lowercase values like us, gb, jp.

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

Google Play language code for the public page request, for example en\_US.

## `appleApp` (type: `object`):

Optional App Store target. Provide {"appId":"570060128"} or {"url":"https://apps.apple.com/us/app/id570060128"}.

## `googlePlayApp` (type: `object`):

Optional Google Play target. Provide {"appId":"com.duolingo"} or a full play.google.com URL.

## `reviewLimitPerPlatform` (type: `integer`):

Maximum reviews to analyze per platform. Google Play usually exposes about 20 public review cards without deeper pagination; App Store can return more from RSS pages.

## `lookbackDays` (type: `integer`):

Prefer reviews inside this window. If a source has no matches inside the window, the actor falls back to the public sample and flags the fallback in warnings.

## `minThemeMentions` (type: `integer`):

Minimum complaint mentions before a theme is treated as a real cluster instead of one-off noise.

## `delivery` (type: `string`):

Dataset is the default. Webhook still writes the local output file and dataset row, then posts the summary payload to the webhook URL.

## `webhookUrl` (type: `string`):

Webhook URL to receive the summary payload when delivery is webhook.

## `snapshotKey` (type: `string`):

Optional override for the monitoring snapshot key. Leave empty to derive it from the configured app IDs and locale.

## `nowIso` (type: `string`):

Optional ISO timestamp override for deterministic tests or backfills.

## `dryRun` (type: `boolean`):

If true, the actor skips dataset delivery, webhook delivery, and snapshot writes. Local output is still written.

## Actor input object example

```json
{
  "productName": "Duolingo",
  "country": "us",
  "language": "en_US",
  "appleApp": {
    "appId": "570060128",
    "country": "us"
  },
  "googlePlayApp": {
    "appId": "com.duolingo",
    "country": "us",
    "language": "en_US"
  },
  "reviewLimitPerPlatform": 20,
  "lookbackDays": 180,
  "minThemeMentions": 2,
  "delivery": "dataset",
  "dryRun": 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 = {
    "productName": "Duolingo",
    "appleApp": {
        "appId": "570060128",
        "country": "us"
    },
    "googlePlayApp": {
        "appId": "com.duolingo",
        "country": "us",
        "language": "en_US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("taroyamada/app-review-cross-platform-intelligence").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 = {
    "productName": "Duolingo",
    "appleApp": {
        "appId": "570060128",
        "country": "us",
    },
    "googlePlayApp": {
        "appId": "com.duolingo",
        "country": "us",
        "language": "en_US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("taroyamada/app-review-cross-platform-intelligence").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 '{
  "productName": "Duolingo",
  "appleApp": {
    "appId": "570060128",
    "country": "us"
  },
  "googlePlayApp": {
    "appId": "com.duolingo",
    "country": "us",
    "language": "en_US"
  }
}' |
apify call taroyamada/app-review-cross-platform-intelligence --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=taroyamada/app-review-cross-platform-intelligence",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "iOS & Android App Review Scraper",
        "description": "Extract user reviews from both the App Store and Google Play into one dataset. Analyze recurring complaints, flag rating drift, and generate ASO summaries.",
        "version": "0.1",
        "x-build-id": "vBg3higzPFlLbOYdu"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/taroyamada~app-review-cross-platform-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-taroyamada-app-review-cross-platform-intelligence",
                "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/taroyamada~app-review-cross-platform-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-taroyamada-app-review-cross-platform-intelligence",
                "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/taroyamada~app-review-cross-platform-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-taroyamada-app-review-cross-platform-intelligence",
                "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": {
                    "productName": {
                        "title": "Product Name",
                        "type": "string",
                        "description": "Optional label for the monitored product. If empty, the actor uses the best store title it finds."
                    },
                    "country": {
                        "title": "Default Country Code",
                        "type": "string",
                        "description": "Default ISO country code for both stores. App Store lookups and review feeds use lowercase values like us, gb, jp.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Google Play Language",
                        "type": "string",
                        "description": "Google Play language code for the public page request, for example en_US.",
                        "default": "en_US"
                    },
                    "appleApp": {
                        "title": "App Store App",
                        "type": "object",
                        "description": "Optional App Store target. Provide {\"appId\":\"570060128\"} or {\"url\":\"https://apps.apple.com/us/app/id570060128\"}."
                    },
                    "googlePlayApp": {
                        "title": "Google Play App",
                        "type": "object",
                        "description": "Optional Google Play target. Provide {\"appId\":\"com.duolingo\"} or a full play.google.com URL."
                    },
                    "reviewLimitPerPlatform": {
                        "title": "Review Sample Limit Per Platform",
                        "minimum": 5,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum reviews to analyze per platform. Google Play usually exposes about 20 public review cards without deeper pagination; App Store can return more from RSS pages.",
                        "default": 20
                    },
                    "lookbackDays": {
                        "title": "Lookback Window (Days)",
                        "minimum": 7,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Prefer reviews inside this window. If a source has no matches inside the window, the actor falls back to the public sample and flags the fallback in warnings.",
                        "default": 180
                    },
                    "minThemeMentions": {
                        "title": "Minimum Theme Mentions",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Minimum complaint mentions before a theme is treated as a real cluster instead of one-off noise.",
                        "default": 2
                    },
                    "delivery": {
                        "title": "Delivery Mode",
                        "enum": [
                            "dataset",
                            "webhook"
                        ],
                        "type": "string",
                        "description": "Dataset is the default. Webhook still writes the local output file and dataset row, then posts the summary payload to the webhook URL.",
                        "default": "dataset"
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Webhook URL to receive the summary payload when delivery is webhook."
                    },
                    "snapshotKey": {
                        "title": "Snapshot Key",
                        "type": "string",
                        "description": "Optional override for the monitoring snapshot key. Leave empty to derive it from the configured app IDs and locale."
                    },
                    "nowIso": {
                        "title": "Debug Timestamp Override",
                        "type": "string",
                        "description": "Optional ISO timestamp override for deterministic tests or backfills."
                    },
                    "dryRun": {
                        "title": "Dry Run",
                        "type": "boolean",
                        "description": "If true, the actor skips dataset delivery, webhook delivery, and snapshot writes. Local output is still written.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
