# App Release Review Regression Report (`taroyamada/app-release-review-regression-report`) Actor

Compare app releases and reviews. No API key / no login. Open Input → Start (1 app + 1 review page ≈ USD 9/report): https://console.apify.com/actors/Gln7fYNAmpSHDsQuD/input From USD 9/report.

- **URL**: https://apify.com/taroyamada/app-release-review-regression-report.md
- **Developed by:** [naoki anzai](https://apify.com/taroyamada) (community)
- **Categories:** Business, Developer tools, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / release review snapshot report

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## App Release Review Regression Report

**What you get:** one capped release-review decision report per run: app version and release date, store rating, review-signal summary, a 0-100 risk score with risk level, and prioritized QA actions.

Sample output from a real run (2026-10-18, the JSON below, 1 report, `release_review_snapshot_report` USD 9):

| app (storefront) | version (released) | store rating (ratings) | reviews analyzed | score / riskLevel | decisionSummary |
|---|---|---|---|---|---|
| Facebook (us) | 583.0.0 (2026-10-14) | 4.53 (28,788,591) | 1 | 35 / low | Snapshot: 1 app source(s), 1 public review signal(s), top issue review_quality. Recommended action: keep this release on normal monitoring. |

[Open Input (leave defaults → Start)](https://console.apify.com/actors/Gln7fYNAmpSHDsQuD/input)

Paid first run ≈ **USD 9** per `release_review_snapshot_report` (1 app, 1 review page). Keep the first run bounded; this does not change the Actor's Store pricing. Open Console Input (deep link above) and run this JSON.

```json
{
  "appleAppIds": [
    "284882215"
  ],
  "appleCountries": [
    "us"
  ],
  "googlePlayIds": [],
  "reportTier": "snapshot",
  "lookbackDays": 7,
  "reviewLimit": 1,
  "maxChargeUsd": 9,
  "maxReports": 1,
  "demoMode": false,
  "dryRun": false
}
```

### Store Quickstart

Run the bounded paid first-run JSON above first; keep report/export options off unless needed.

```json
{
  "appleAppIds": [
    "284882215"
  ],
  "appleCountries": [
    "us"
  ],
  "googlePlayIds": [],
  "reportTier": "snapshot",
  "lookbackDays": 7,
  "reviewLimit": 1,
  "maxChargeUsd": 9,
  "maxReports": 1,
  "demoMode": false,
  "dryRun": false
}
```

Run this input to exercise the documented first-run path. Review the pricing section before increasing the scope.

```json
{
  "demoMode": false,
  "dryRun": false,
  "reportTier": "snapshot",
  "maxChargeUsd": 9,
  "maxReports": 1,
  "appleAppIds": [
    "284882215"
  ],
  "appleCountries": [
    "us"
  ],
  "googlePlayIds": [
    "com.duolingo"
  ],
  "lookbackDays": 30,
  "reviewLimit": 25
}
```

### Use with Apify MCP

Exact actor: `taroyamada/app-release-review-regression-report`

Sample input JSON:

```json
{
  "appleAppIds": [
    "284882215"
  ],
  "appleCountries": [
    "us"
  ],
  "googlePlayIds": [
    "com.duolingo"
  ],
  "reportTier": "snapshot",
  "lookbackDays": 30,
  "reviewLimit": 3,
  "maxChargeUsd": 3,
  "maxReports": 1
}
```

### Run the next report

- [Compare reviews across app stores](https://apify.com/taroyamada/app-review-cross-platform-intelligence?utm_source=apify_internal\&utm_medium=readme_next_report\&utm_campaign=v37_internal_flow\&utm_content=app-release-review-regression-report__app-review-cross-platform-intelligence) before turning release-specific changes into a QA backlog.
- [Benchmark release review changes across a category](https://apify.com/taroyamada/app-release-category-review-benchmark-report) when one app-level regression needs portfolio context.

Start with $9 / `release_review_snapshot_report`; upgrade to $29 / `release_regression_report` only when the first report needs deeper action detail.
Internal links improve discovery only. Qualified forecast still requires accounted paid usage.

### Proof-focused buyer summary

Built for mobile product, QA, support, and app growth teams who need to decide whether a public app release created review regressions that need QA or product action.

- Buy this when: Replaces the first manual pass of reading recent public app reviews after a release and turning them into QA actions.
- Entry: $9 / `release_review_snapshot_report` - $9 gives one release review risk snapshot with score, source URLs, and three QA actions.
- Premium: $29 / `release_regression_report` - $29 adds deeper issue grouping, QA backlog suggestions, and regression triage context.
- Output promise: decision summary, score, three prioritized actions, source URLs, warnings, `chargedEvent`, `chargedUsd`, and `previewReport.nextRunInput`.
- Safety: keep `maxChargeUsd` equal to the tier price. Demo, dry run, blocked/private sources, failed sources, and cap-limited runs are no-charge.
- Not promised: rankings, revenue, conversion lift, sales lift, legal/procurement/financial advice, or private-source enrichment.

Entry first-run input:

```json
{
  "demoMode": false,
  "dryRun": false,
  "reportTier": "snapshot",
  "maxChargeUsd": 9,
  "maxReports": 1,
  "appleAppIds": [
    "284882215"
  ],
  "appleCountries": [
    "us"
  ],
  "googlePlayIds": [
    "com.duolingo"
  ],
  "lookbackDays": 30,
  "reviewLimit": 25
}
```

Premium upgrade input:

```json
{
  "demoMode": false,
  "dryRun": false,
  "reportTier": "regression",
  "maxChargeUsd": 29,
  "maxReports": 1,
  "appleAppIds": [
    "284882215"
  ],
  "appleCountries": [
    "us"
  ],
  "googlePlayIds": [
    "com.duolingo"
  ],
  "lookbackDays": 30,
  "reviewLimit": 50
}
```

Find out whether a public app release is creating review regressions that deserve product or QA attention. This Actor turns public App Store and Google Play signals into a short decision report: risk score, repeated issue themes, prioritized actions, and QA backlog candidates.

Use it when you need to answer:

- Did the latest release trigger new crash, login, subscription, performance, or sync complaints?
- Which public review themes should become QA backlog items?
- Is there enough evidence to open a release regression triage, or should the team keep watching?

### Pricing

This Actor uses pay per event pricing with a safety cap.

| Tier | Event | Price | Best for |
| --- | --- | ---: | --- |
| Snapshot | `release_review_snapshot_report` | $9 | One app release review check with score and three actions |
| Regression | `release_regression_report` | $29 | Deeper issue grouping, backlog suggestions, and cross-source triage |

A future watch summary tier is designed but hidden until real paid demand is proven. It is not available from the public input schema.

Set `maxChargeUsd` to the tier price you want. If the cap is lower than the selected tier, the run returns a no-charge `limit_reached` summary.

### What You Get

Each paid report includes:

- `decisionSummary` for the release triage call
- `score` and `riskLevel`
- App coverage across public App Store / Google Play sources
- Public review signal summary
- Topic spikes such as stability, login, subscription, performance, ads, or sync
- 3 to 5 prioritized actions
- Source URLs, warnings, confidence, and billing event fields
- `previewReport.nextRunInput` so the next run is easy to launch

### First Run

```json
{
  "appleAppIds": ["284882215"],
  "appleCountries": ["us"],
  "googlePlayIds": ["com.duolingo"],
  "reportTier": "snapshot",
  "maxChargeUsd": 9,
  "maxReports": 1,
  "lookbackDays": 30,
  "reviewLimit": 25,
  "demoMode": false,
  "dryRun": false
}
```

Upgrade to `"reportTier": "regression"` and `"maxChargeUsd": 29` when you want the deeper QA backlog version.

### Source And Safety Rules

Allowed sources are public App Store metadata/review RSS, public iTunes Lookup API, and public Google Play listing pages. This Actor does not use App Store Connect, Apple Search Ads, private dashboards, login-only pages, or paid ASO data.

The report does not profile reviewers, extract personal contact details, or claim ranking, revenue, rating, or sales improvements. Treat public-source findings as triage evidence that should be verified by your product, support, or QA team.

### Related Actors

- Use `mobile-app-listing-gap-report` when you need App Store / Google Play listing optimization ideas.
- Use this Actor when you already shipped or are about to ship and need release risk signals from public reviews.

# Actor input Schema

## `appleAppIds` (type: `array`):

Public App Store numeric app IDs to check. Uses public iTunes Lookup and public review RSS only.

## `appleCountries` (type: `array`):

Storefront country codes such as us, jp, gb.

## `googlePlayIds` (type: `array`):

Public Google Play package IDs to include in the app coverage.

## `reportTier` (type: `string`):

Snapshot returns a compact release review checklist. Regression adds deeper issue grouping and QA backlog suggestions.

## `releaseVersion` (type: `string`):

Optional version label for the release you want to triage.

## `releaseDate` (type: `string`):

Optional release date in YYYY-MM-DD format. Used as report context, not as a guarantee that every source exposes release-level review attribution.

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

Recent public review window used for theme and risk scoring.

## `reviewLimit` (type: `integer`):

Maximum public review samples per app/source.

## `maxChargeUsd` (type: `number`):

Safety cap. If below the selected report tier price, the Actor returns a no-charge limit_reached summary.

## `maxReports` (type: `integer`):

This Actor produces one decision report per run to keep pricing predictable.

## `demoMode` (type: `boolean`):

Returns a no-charge example report shape without using public sources.

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

No-charge validation path. Does not fetch public sources or create a paid report.

## `sourceDatasetId` (type: `string`):

Advanced only. Optional future workflow hook for user-provided app lists. The first-run example does not require it.

## Actor input object example

```json
{
  "appleAppIds": [
    "284882215"
  ],
  "appleCountries": [
    "us"
  ],
  "googlePlayIds": [],
  "reportTier": "snapshot",
  "lookbackDays": 7,
  "reviewLimit": 1,
  "maxChargeUsd": 9,
  "maxReports": 1,
  "demoMode": false,
  "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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("taroyamada/app-release-review-regression-report").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("taroyamada/app-release-review-regression-report").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call taroyamada/app-release-review-regression-report --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,taroyamada/app-release-review-regression-report"
        }
    }
}
```

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

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Gln7fYNAmpSHDsQuD/builds/ByI64FSyY6OZWZmlv/openapi.json