# Google Play Scraper โ App Data, Reviews & ASO API (`logiover/google-play-data-api`) Actor
Unofficial Google Play API alternative. Scrape Play Store app data & reviews without login; export app data to CSV/JSON. No API key, no browser.
- **URL**: https://apify.com/logiover/google-play-data-api.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Developer tools, SEO tools
- **Features:** Limited permissions
- **Stats:** 14 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.70 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.
Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event
## What's an Apify Actor?
An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.
## How to integrate an Actor?
If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.
For examples already wired to this Actor's own input schema, see the [API](#api) section below.
Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).
# README
## Google Play Scraper โ App Data, Reviews, Top Charts & ASO API (No API Key)
    
An unofficial **Google Play Store scraper** and REST-style **Android app data API** in a single Apify Actor. Extract Play Store **app details, user reviews, ratings, top charts, ASO keyword suggestions, Android permissions and Google Play data-safety info** โ no Play Console account, no OAuth, no API key, no headless browser. Just fast HTTP and clean JSON. **Ten endpoints (modes) share one input form**, and every result is tagged with `_mode` so you can mix modes in a single dataset.
> ### ๐ Why this Google Play scraper?
>
> **10 endpoints in one Actor** ยท up to **100,000+ reviews per app** ยท top charts by country & category ยท ASO keyword suggestions ยท pure HTTP, sub-3s cold start ยท 4 pre-built dataset views ยท export to JSON / CSV / Excel. The unofficial **Google Play API alternative** for Android developers, ASO platforms, app-intelligence tools and AI agents.
***
### โจ What this Actor does / Key features
- ๐ **Ten modes, one form** โ search, app, reviews, list, similar, developer, suggest, permissions, datasafety, categories.
- ๐ฑ **Full app details** โ title, summary, description (+ HTML), icon, header image, screenshots, promo video, genre & categories.
- โญ **Ratings & reach** โ floating-point `score`, `scoreText`, total ratings/reviews, exact 1โ5 star `histogram`, install bands and best-estimate real installs.
- ๐ฌ **Reviews at scale** โ up to **100,000+ reviews per app**, auto-paginated, with reviewer, star rating, full text, date, app version, helpful-votes and developer reply.
- ๐ **Top charts** โ TOP_FREE / TOP_PAID / TOP_GROSSING / NEW / TRENDING by category and country.
- ๐ **ASO keyword research** โ ranked autocomplete `suggest` terms plus keyword `search` rankings for long-tail ASO mining.
- ๐ฐ **Monetization signals** โ price, currency, free flag, in-app purchases + IAP range, ad-supported flag.
- ๐ **Privacy & compliance** โ Android permissions list and the Google Play data-safety section for vendor/GDPR reviews.
- ๐ **Locale-aware** โ set `country` + `language`; the same app differs per locale.
- ๐ **No API key** โ reads publicly visible `play.google.com` pages over plain HTTP; only an Apify account required.
#### The 10 modes
| Mode | What it returns |
|---|---|
| `search` | Keyword search results (Play Store search bar) |
| `app` | Full details for one app or many (batch, 5ร concurrency) |
| `reviews` | Up to 100,000+ reviews per app, auto-paginated |
| `list` | Top charts (free / paid / grossing) by category |
| `similar` | "Similar apps" for a given app |
| `developer` | Every app published by a developer |
| `suggest` | Autocomplete suggestions for ASO keyword research |
| `permissions` | Android permissions an app declares |
| `datasafety` | Google Play data-safety section |
| `categories` | Full list of Google Play category codes |
### ๐ Quick start (3 steps)
1. **Configure** โ pick a **Mode** and fill the fields it needs: an `appId` for app-targeted modes (e.g. `com.spotify.music`), a `query` for search/suggest, or a `devId` for developer. Set `country` and `language`.
2. **Run** โ click **Start**. The Actor calls the chosen Play Store endpoint and streams tagged rows into your dataset.
3. **Get your data** โ open the **Output** tab (Overview, App catalog, Reviews or App details view) and export to **JSON, CSV, Excel, HTML, RSS or JSONLines**, or pull it via the Apify API.
### ๐ฅ Input
Pick a `mode`, then fill the fields that mode uses. Everything else is optional.
#### Example โ keyword search for meditation apps
```json
{
"mode": "search",
"query": "meditation",
"country": "us",
"language": "en",
"maxResults": 50
}
```
#### Example โ pull 5,000 newest reviews for an app
```json
{
"mode": "reviews",
"appId": "com.spotify.music",
"country": "us",
"reviewSort": "NEWEST",
"maxResults": 5000
}
```
#### Example โ top free finance apps in Germany
```json
{
"mode": "list",
"collection": "TOP_FREE",
"category": "FINANCE",
"country": "de",
"language": "de",
"maxResults": 200
}
```
| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `mode` | string | Which Play Store endpoint to call (see the 10 modes above). **Required.** | `search` |
| `appId` | string | Single app ID (value after `id=` in the Play URL). Used by app/reviews/similar/permissions/datasafety. | โ |
| `appIds` | array | Batch app IDs for multi-app runs (app/reviews/permissions/datasafety). | `[]` |
| `query` | string | Keyword for `search`, or partial term for `suggest` autocomplete. | โ |
| `devId` | string | Developer name as on Google Play (e.g. `Spotify AB`). Used by `developer`. | โ |
| `collection` | string | Top chart for `list`: TOP_FREE, TOP_PAID, TOP_GROSSING, NEW_FREE, NEW_PAID, TRENDING. | `TOP_FREE` |
| `category` | string | Category code for `list` (e.g. `GAME`, `FINANCE`). Run `categories` mode for all codes. | โ |
| `age` | string | Age-band filter for game categories in `list`. | โ |
| `reviewSort` | string | `NEWEST`, `RATING` or `HELPFULNESS` (reviews mode). | `NEWEST` |
| `reviewScore` | integer | Return only reviews with this exact star rating (1โ5). | โ |
| `country` | string | ISO 3166-1 alpha-2 country code (e.g. `us`, `de`, `jp`). Applies to every mode. | `us` |
| `language` | string | BCP 47 language code (e.g. `en`, `de`, `ja`). | `en` |
| `maxResults` | integer | Max results (per-app for reviews; overall otherwise). Some modes cap at ~250. | โ |
| `fullDetail` | boolean | Enrich search/list/similar/developer rows with full 47+ field app detail (slower). | `false` |
| `shortPermissions` | boolean | Compact permission strings instead of full objects (permissions mode). | `false` |
> **Finding an App ID:** open the app on play.google.com and copy the value after `id=` in the URL (e.g. `https://play.google.com/store/apps/details?id=com.spotify.music` โ `com.spotify.music`).
### ๐ค Output
Documented flat fields per mode โ every item carries `_mode` and `scrapedAt`. Here is a trimmed `app`-mode sample record:
```json
{
"_mode": "app",
"appId": "com.spotify.music",
"title": "Spotify: Music and Podcasts",
"developer": "Spotify AB",
"developerId": "Spotify+AB",
"score": 4.3,
"scoreText": "4.3",
"ratings": 32871004,
"reviews": 4210233,
"histogram": { "1": 2100000, "2": 610000, "3": 1400000, "4": 3900000, "5": 24800000 },
"installs": "1,000,000,000+",
"minInstalls": 1000000000,
"realInstalls": 1284500110,
"free": true,
"price": 0,
"currency": "USD",
"offersIAP": true,
"IAPRange": "$0.99 - $199.99 per item",
"adSupported": false,
"genre": "Music & Audio",
"genreId": "MUSIC_AND_AUDIO",
"contentRating": "Teen",
"androidVersionText": "Varies with device",
"version": "8.9.0.100",
"released": "Oct 7, 2008",
"developerEmail": "android-support@spotify.com",
"developerWebsite": "https://www.spotify.com",
"privacyPolicy": "https://www.spotify.com/legal/privacy-policy/",
"url": "https://play.google.com/store/apps/details?id=com.spotify.music",
"scrapedAt": "2026-07-06T12:00:00.000Z"
}
```
๐ Full field reference (click to expand)
| Group | Fields |
|-------|--------|
| App details | `appId`, `title`, `summary`, `description`, `descriptionHTML`, `icon`, `headerImage`, `screenshots[]`, `video`, `url` |
| Ratings | `score`, `scoreText`, `ratings`, `reviews`, `histogram` (1โ5 star counts) |
| Reach | `installs`, `minInstalls`, `maxInstalls`, `realInstalls` |
| Reviews (reviews mode) | `userName`, `score`, `text`, `date`, `version`, `thumbsUp`, `replyText`, `replyDate` |
| Pricing | `price`, `currency`, `free`, `priceText`, `offersIAP`, `IAPRange` |
| Metadata | `version`, `recentChanges`, `released`, `updated`, `androidVersion`, `androidVersionText`, `contentRating`, `genre`, `genreId`, `categories` |
| Developer | `developer`, `developerId`, `developerEmail`, `developerWebsite`, `developerAddress`, `developerLegalName` |
| Compliance | `privacyPolicy`, `adSupported`, permissions list, data-safety section |
| ASO (suggest mode) | ranked autocomplete search terms |
| Universal | `_mode`, `scrapedAt` (ISO 8601) |
### ๐ก Use cases
- **ASO & app store optimization** โ track keyword rankings with `search`, mine long-tail keywords with `suggest`, monitor competitor metadata changes.
- **App market intelligence** โ bulk-ingest `app` details, install bands, top charts by country and rating histograms into dashboards.
- **Review monitoring & sentiment** โ pull tens of thousands of reviews for your app or competitors, filter by star rating, alert on 1-star spikes.
- **Privacy & compliance research** โ extract Android permissions and data-safety sections for GDPR/CCPA vendor reviews and MDM policy audits.
- **AI agents & RAG** โ wrap the Actor as a tool so an LLM can answer "top mindfulness apps in Germany?" or embed app descriptions + reviews.
### ๐ฅ Who uses it
Android developers & mobile PMs ยท ASO platforms and agencies ยท app-intelligence & market-research firms ยท competitive-intel and growth teams ยท privacy/compliance and security auditors ยท data scientists and AI-agent builders needing structured Play Store data.
### ๐ฐ Pricing
This Actor runs on a simple **pay-per-result** model โ you pay for the items you extract, with no separate Apify platform fees to calculate. Try it on the **free tier** first, then scale up. See the **Pricing** tab on this page for the current rate.
### โ Frequently Asked Questions
**Do I need a Google account or API key?**
No. This is an unofficial scraper that reads data publicly visible on `play.google.com`, the same way a browser would. You only need an Apify account โ no Play Console account, no OAuth, no API key.
**Is this a Google Play API alternative?**
Yes. It works as an unofficial Google Play API alternative, returning REST-style JSON for app details, reviews, ratings and top charts โ without a Play Console account, OAuth or API key.
**Can I scrape Google Play without an API or login?**
Yes. This Play Store scraper reads publicly visible pages over plain HTTP, so you can scrape Google Play app data and reviews without login, without an API key, and without a headless browser.
**How many reviews can I pull per app?**
Reviews are auto-paginated, so you can pull anywhere from a handful to 100,000+ per app on popular titles. Use `reviewSort: NEWEST` and increase `maxResults`; the Actor handles continuation tokens for you. Set `reviewScore: 1` to fetch only 1-star reviews for negative-sentiment monitoring.
**How do I scrape Google Play reviews for a specific app?**
Set mode to `reviews` and pass the `appId` (the value after `id=` in the Play Store URL). Reviews auto-paginate, so you can pull thousands per app sorted by newest or rating.
**Can I get the top free apps by category and country?**
Yes. Use mode `list` with a collection like TOP_FREE, a category code such as GAME or FINANCE, and a country code to fetch that country's Play Store top chart.
**How do I do ASO keyword research with Google Play data?**
Use mode `suggest` with a partial query to pull Google Play autocomplete terms, or mode `search` to see ranking results โ ideal for mining long-tail ASO keywords.
**How accurate are the rating and install numbers?**
`score` is the floating-point average Google exposes and `scoreText` is the rounded display value. `histogram` gives exact 1โ5 star counts. `minInstalls`/`maxInstalls` are Google's official install bands per country, and `realInstalls` is the closest available estimate.
**Can I run several modes in one run?**
Each run executes one mode. To combine modes, call the Actor multiple times and join the datasets on `appId`. Every item carries a `_mode` field, so mixed datasets stay easy to filter.
**How do I export Google Play data to CSV or JSON?**
Run any mode, then download the dataset as CSV, JSON, Excel (XLSX), HTML, RSS or JSONLines from the run's Storage tab, or pull it via the Apify API. Pre-built views let you export with no post-processing.
### ๐ More app, store & product-intelligence scrapers by logiover
Building an app-store or product-intelligence dataset? Pair this with:
| Actor | What it does |
|---|---|
| [App Store Data API](https://apify.com/logiover/app-store-data-api) | Unofficial Apple App Store data API (apps, reviews, charts) |
| [Product Hunt Daily Launches](https://apify.com/logiover/product-hunt-daily-launches-scraper) | New product launches, makers & upvotes |
| [G2 Software Reviews Scraper](https://apify.com/logiover/g2-reviews-scraper) | B2B software reviews & ratings |
| [Trustpilot Reviews Scraper](https://apify.com/logiover/trustpilot-reviews-scraper) | Company reviews, ratings & sentiment |
| [Steam Game Reviews Scraper](https://apify.com/logiover/steam-game-reviews-scraper) | Game reviews & scores from Steam |
| [Similarweb Scraper](https://apify.com/logiover/similarweb-scraper) | Traffic & engagement estimates |
| [SERP Keyword Research](https://apify.com/logiover/serp-keyword-research) | Search-engine keyword & ranking data |
| [Google News Scraper](https://apify.com/logiover/google-news-scraper) | News coverage by keyword |
| [NPM Package Intelligence](https://apify.com/logiover/npm-package-intelligence-scraper) | Package stats & dependency intel for devs |
๐ Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** โ 180+ actors across real estate, jobs, crypto, social media & B2B data.
### โฐ Scheduling & integration
Schedule this Actor on Apify to track rankings, reviews or metadata daily or weekly. Export results to JSON, CSV or Excel, sync to Google Sheets, or push to your database, BI tools and webhooks through the Apify API. Call it from your stack via `run-sync-get-dataset-items`, the JavaScript/Python clients, or no-code tools like **Make, n8n and Zapier**.
### โญ Support & feedback
Found a bug or need an extra field? Open an issue on the **Issues** tab โ response is usually fast. If this Actor saves you time, a **โ
โ
โ
โ
โ
review** on the Store page genuinely helps and is hugely appreciated. ๐
### โ๏ธ Legal
This Actor extracts only publicly visible Google Play data and is intended for legitimate research, analytics and app-intelligence use. You are responsible for complying with Google Play's terms of service and any applicable local laws.
***
This Actor is an independent tool. It is not affiliated with, endorsed by, or sponsored by Google Play; Google Play and all other trademarks mentioned here are the property of their respective owners.
### How much Google Play data can you extract in one run?
A single run returned **30 rows** in 6 seconds on the example input. That example is deliberately narrow; the result limit and the input list are both yours to widen. That is roughly **300 rows a minute**.
There is no hard ceiling built into this Actor. What bounds a run is the result limit you set, the breadth of the input you give it, and how much Google Play itself publishes. Because billing is per result, a wider run costs proportionally more and a narrow one costs almost nothing โ so it is worth starting small and scaling once the output looks right.
### Google Play scraping โ frequently asked questions
#### Do I need a Google Play API key, account or login?
No. This Actor reads publicly available pages and feeds, so there is nothing to register for and no credentials to manage.
#### How do I export Google Play data to CSV, Excel, JSON or Google Sheets?
Open the **Storage** tab after a run and pick the format you want โ CSV, Excel, JSON, XML or an HTML table. For Google Sheets, Airtable or a database, use the dataset URL or the Apify API so the sheet refreshes itself on every run.
#### Can I schedule this Google Play scraper to run daily or hourly?
Yes. Use the **Schedules** tab and pick a cadence. Daily is enough for most tracking work; pick hourly only if the rows you care about really do change that fast.
#### How many rows can I get, and what does it cost?
See the volume section above for a measured figure. Billing is per result, so you pay for the rows you actually receive and a run that finds nothing costs nothing.
#### Is scraping Google Play legal?
This Actor collects only information that Google Play publishes publicly. It does not log in, does not defeat access controls and does not touch private data. You remain responsible for how you use the output, including under GDPR and similar rules where personal data is involved.
#### What happens if Google Play blocks the run or changes its layout?
A refused exit IP is swapped for a fresh one within a quarter of a second and retried, and rate limiting is waited out rather than fought. If nothing gets through, the run **fails with the reason** instead of reporting success with zero rows โ so an empty result always means "no matches", never "the source would not answer".
#### Can I use this with an AI agent, LangChain or an MCP client?
Yes. The Actor is callable over the Apify API and through Apify's MCP server, so an agent can run it and read the dataset back as a tool call.
### ๐ Changelog
#### 2026-11-01
- Monthly health check (2026-11-01): a live run on the current build completed successfully and returned data. Input options, output fields and pricing are unchanged.
- README refreshed: 1 link to renamed Actors updated, 1 link to retired Actors removed; independence disclaimer added.
#### 2026-10-15
- A run that reaches its maximum cost per run now stops cleanly with its results saved and a status message, instead of ending as aborted.
- A proxy group your account cannot use no longer stops the run at start-up; it falls back to the default Apify Proxy.
- Memory is managed within the run's own limit, which removes a rare out-of-memory crash on large pages.
- The prefilled example for `maxResults` is now 750 (was 100).
- The default used when the field is left out for `maxResults` is now 6,000 (was 100).
#### 2026-09-23
- Fleet-wide quality audit. Verified end to end against live data and re-checked the input schema, the output columns and the run configuration.
- Output verified on a live run: 20 columns returned, 100.0% of cells populated.
- Run reliability reviewed: 98.8% of public runs succeeded in the last 30 days.
- Input schema, output schema and pricing configuration reviewed.
#### 2026-09-01
- Fleet-wide health check. Verified against this Actor's real run history: 30-day success rate, output row counts, per-field fill rates, and peak memory against the configured memory limit.
- Reviewed for the failure patterns that have cost this fleet runs โ unguarded proxy setup, retry loops that can outlast the run's own time budget, and full-page HTML parsing that can exhaust a small container.
- No change to input, output fields or scraping logic.
#### 2026-08-11
- Maintenance release: refreshed the build and dependencies.
- Re-verified live execution, non-empty structured output and dataset field/type integrity.
- Reviewed reliability (retries, pagination) and output quality as part of a full-fleet QA pass.
#### 2026-08-01
- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Declared 21 dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder.
- Declared 21 nullable dataset fields from typed live cloud samples so the output contract is no longer an empty placeholder or brittle to sparse modes.
#### 2026-07-06
- โจ README overhaul: richer app-mode output sample, three ready-to-run example scenarios, full field-group reference, expanded app/product-intelligence cross-links, and clearer quick-start.
#### 2026-07-01
- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.
#### 2026-06-15
- Reliability pass: re-verified end-to-end on live data with real-world inputs. Routine maintenance build.
#### 2026-06-07
- Docs: added coverage for using the actor as a Google Play API alternative, exporting Play Store data to CSV/JSON, and scraping Google Play app data without login.
#### 2026-06-05
- Reliability fix: results are no longer dropped by strict output validation โ runs complete cleanly at high volume.
- Stability & performance hardening; fresh rebuild.
#### 2026-06-04
- Verified live & refreshed build โ reliability/maintenance pass.
***
\*Maintained: last verified 2026-11-01 โ checked end-to-end against live run history (reliability, output fields and types, and time/memory budgets).
# Changelog
This Actor's version history is a separate document: https://apify.com/logiover/google-play-data-api/changelog.md
# Actor input Schema
## `mode` (type: `string`):
Which Google Play endpoint to call.
โข **search** โ keyword search (most common)
โข **app** โ full details for one or more app IDs
โข **reviews** โ user reviews with pagination
โข **list** โ top charts (free/paid/grossing) by category
โข **similar** โ apps similar to a given app
โข **developer** โ all apps by a developer
โข **suggest** โ autocomplete suggestions (great for ASO keyword research)
โข **permissions** โ Android permissions list (privacy/security audits)
โข **datasafety** โ Google Play data safety section
โข **categories** โ full list of Google Play category codes
## `appId` (type: `string`):
Single Google Play app ID โ the value after `id=` in the Play Store URL. E.g. `com.spotify.music`. Used by **app**, **reviews**, **similar**, **permissions**, **datasafety** modes.
## `appIds` (type: `array`):
Array of app IDs for batch operations. Used by **app**, **reviews**, **permissions**, **datasafety** modes when you want multiple apps in one run. Adds to (or replaces) the single App ID field above.
## `query` (type: `string`):
Keyword to search for in **search** mode, or partial term for **suggest** mode autocomplete. Required when mode is "search" โ the run stops immediately without it.
## `devId` (type: `string`):
Developer name as it appears on Google Play (URL-encoded). E.g. `Spotify+AB` or `Google+LLC`. Used by **developer** mode.
## `collection` (type: `string`):
Which top chart to fetch in **list** mode.
## `category` (type: `string`):
Optional category filter for **list** mode. Leave as "All categories" for the overall top charts. (Run mode=categories to fetch the full up-to-date code list.)
## `age` (type: `string`):
Age-band filter for game categories in **list** mode.
## `reviewSort` (type: `string`):
How reviews are ordered when fetched from Google Play.
## `reviewScore` (type: `integer`):
Optional: return only reviews with this exact star rating (1โ5). Leave blank for all ratings.
## `country` (type: `string`):
Country storefront. Affects localized title, description, ratings, and which apps are returned. Leave on the default (United States) for the broadest catalog.
## `language` (type: `string`):
Interface / listing language. Leave on the default (English) for the broadest coverage.
## `maxResults` (type: `integer`):
Maximum results to return. For **reviews** mode, this is per-app. For **list/search/similar/developer** modes, this is overall. Leave on the default (100) for a fast, cheap run; raise it to pull more (some Google Play modes cap at ~250 per run).
## `fullDetail` (type: `boolean`):
For **search**, **list**, **similar**, **developer** modes: if enabled, each result is enriched with the full 47+ field app detail (slower, more expensive). Disable for quick lookups.
## `shortPermissions` (type: `boolean`):
For **permissions** mode: if enabled, returns a compact list of permission strings instead of the full permission objects.
## Actor input object example
```json
{
"mode": "search",
"appId": "com.spotify.music",
"appIds": [],
"query": "spotify",
"devId": "Spotify AB",
"collection": "TOP_FREE",
"category": "",
"age": "",
"reviewSort": "NEWEST",
"country": "us",
"language": "en",
"maxResults": 750,
"fullDetail": false,
"shortPermissions": false
}
```
# Actor output Schema
## `results` (type: `string`):
Full results dataset. Switch between Overview, App catalog, Reviews, and App details views depending on which mode you ran.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"query": "photo editor",
"maxResults": 750
};
// Run the Actor and wait for it to finish
const run = await client.actor("logiover/google-play-data-api").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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"query": "photo editor",
"maxResults": 750,
}
# Run the Actor and wait for it to finish
run = client.actor("logiover/google-play-data-api").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 '{
"query": "photo editor",
"maxResults": 750
}' |
apify call logiover/google-play-data-api --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"type": "http",
"url": "https://mcp.apify.com/?tools=fetch-actor-details,logiover/google-play-data-api"
}
}
}
```
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 ` 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/cuSaFiPrAB674738o/builds/5j5K5KHshzXusXDwF/openapi.json