# Google Play Store Scraper (`aerodynamic_tripod/my-actor`) Actor

Extract Google Play app details and ranked keyword search results with ratings, installs, pricing, developers, localization, and more. No API key or browser required.

- **URL**: https://apify.com/aerodynamic\_tripod/my-actor.md
- **Developed by:** [SearchShark Tools](https://apify.com/aerodynamic_tripod) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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/actors/running/actors-in-store.md#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

## 🎮 Google Play Store Scraper

**Google Play Store Scraper** lets you extract **structured app data and ranked search results from Google Play** without using a browser or requiring a Google API key.

Research apps, analyze competitors, monitor keyword visibility, collect developer information, compare ratings and installs, and retrieve **country-specific pricing and localized Google Play data**.

- 🔎 **Search Google Play:** find apps by keyword and preserve their observed ranking
- 📱 **Extract app details:** collect ratings, installs, pricing, descriptions, developer information, and more
- 🌍 **Localize results:** choose a country and language for regional Google Play data
- 💰 **Get regional pricing:** extract free/paid status, currency, and localized app prices
- 🏆 **Preserve search rank:** keep the position where each app appeared for every search term
- ⚡ **Fast HTTP-first scraping:** no Playwright, Puppeteer, or browser required
- 📦 **Batch app lookups:** process multiple Google Play apps efficiently
- 🔌 **Automation-ready output:** export structured results through Apify Dataset, API, and integrations

***

### 📦 What data does Google Play Store Scraper extract?

#### 📱 App details

| | |
| --- | --- |
| 🆔 **Package ID** | 📱 **App name** |
| 🏢 **Developer name** | 🆔 **Developer ID** |
| 🔗 **Developer URL** | 🌐 **Developer website** |
| ✉️ **Developer email** | 🏷 **Category** |
| 🔞 **Content rating** | 📝 **Full description** |
| ✏️ **Short description** | 🖼 **App icon** |
| 📸 **Screenshots** | ⭐ **Rating** |
| 👥 **Rating count** | 💬 **Review count** |
| 📥 **Install count** | 📊 **Minimum installs** |
| 📅 **Release date** | 💵 **Price** |
| 💱 **Currency** | 🆓 **Free / paid status** |
| 🛒 **In-app purchase price range** | 📢 **Contains ads** |
| 🔗 **Google Play URL** | 🌍 **Country & language** |

> **Missing fields are returned as `null` when Google Play does not expose the information.** The Actor does **not invent app data**.

***

### 🚀 Features

Google Play Store Scraper is designed for **app research, competitor intelligence, keyword analysis, and automated Google Play data collection**.

- **Multiple apps per run:** submit multiple package IDs or Google Play URLs
- **Multiple search terms:** search several keywords in one Actor run
- **Batch app-detail requests:** apps are internally grouped into small efficient batches
- **Rank-preserving search:** every search result keeps its observed Google Play position
- **Country localization:** retrieve market-specific pricing and availability context
- **Language localization:** retrieve translated titles, descriptions, and categories when available
- **Free and paid app detection:** normalize Google Play pricing into structured fields
- **Featured-result support:** Google's featured search result is parsed correctly
- **Regular-result support:** standard ranked app cards use a separate normalized parser
- **Partial failure protection:** one failed query does not erase successful results from other queries
- **Automatic retries:** temporary network errors and rate limits are retried with delays
- **HTTP-first architecture:** normal operation does not launch browser automation
- **API-friendly output:** results are stored as predictable structured Dataset rows

***

## ⬇️ Input

You can configure Google Play Store Scraper directly from the **Apify Console** or start it programmatically through the **Apify API**.

***

### 📱 App package IDs or Google Play URLs

Enter one or more Google Play applications.

You can use a package ID:

```text
com.spotify.music
com.mojang.minecraftpe
com.king.candycrushsaga
```

Or a full Google Play URL:

```text
https://play.google.com/store/apps/details?id=com.spotify.music
```

You can mix package IDs and URLs in the same run.

Example:

```text
com.spotify.music
https://play.google.com/store/apps/details?id=com.mojang.minecraftpe
com.king.candycrushsaga
```

**Duplicate package IDs are processed only once in app-detail mode.**

***

### 🔎 Search terms

Enter one or more Google Play search queries.

Example:

```text
spotify
photo editor
weather
fitness tracker
```

**Each search term is processed independently.**

For example:

```text
Search term:
spotify
```

may return:

```text
Rank 1 → Spotify: Music and Podcasts
Rank 2 → Spotify: Music & Podcasts
Rank 3 → Spotify for Artists
Rank 4 → Spotify for Creators
Rank 5 → Spotify Kids
```

The exact results can change as Google Play rankings change.

***

### 🌎 Country

Enter the **two-letter country code** used by Google Play.

Default:

```text
US
```

Examples:

```text
US
PH
GB
CA
AU
DE
ES
```

Country can affect:

- **App pricing**
- **Currency**
- **Regional availability**
- **Google Play market context**

For example, the same paid app may return:

```text
US → USD → $6.99
PH → PHP → ₱69.00
```

***

### 🌐 Language

Enter the Google Play **language code**.

Default:

```text
en
```

Examples:

```text
en
es
de
fr
it
pt
```

Language can change localized:

- **App names**
- **Descriptions**
- **Short descriptions**
- **Categories**

For example:

```text
en-US:
Spotify: Music and Podcasts
Music & Audio
```

and:

```text
es-ES:
Spotify: música y podcasts
Música y audio
```

***

### 🔢 Maximum results per search

Set the maximum number of ranked apps to save for **each search term**.

```text
Minimum: 1
Default: 20
Maximum: 30
```

For example:

```text
Search terms:
spotify
music player

Maximum results per search:
10
```

can return up to:

```text
10 results for spotify
+
10 results for music player
=
20 Dataset rows
```

The requested number is a **maximum, not a guarantee**.

Google Play may expose fewer applications for a search.

> The current version uses **Google Play's initial ranked application cluster only**. It does not attempt deep search pagination.

***

### 🧪 Example input

```json
{
  "packageIdsOrUrls": [
    "com.spotify.music",
    "com.mojang.minecraftpe"
  ],
  "searchTerms": [
    "spotify"
  ],
  "country": "US",
  "language": "en",
  "maxResultsPerSearch": 10
}
```

This input performs:

```text
2 app-detail lookups
+
1 Google Play search
```

***

## ⬆️ Output

Results are stored in the Actor's default **Apify Dataset**.

You can access them from:

```text
Output
Storage
Apify API
Integrations
```

The Actor can produce **two types of Dataset rows**:

```text
appDetails
search
```

***

### 📱 Example app-detail result

```json
{
  "mode": "appDetails",
  "packageId": "com.spotify.music",
  "appName": "Spotify: Music and Podcasts",
  "developerName": "Spotify AB",
  "developerId": "6523013212965523194",
  "developerWebsite": "https://www.spotify.com",
  "developerEmail": "support@spotify.com",
  "category": "Music & Audio",
  "contentRating": "Teen",
  "rating": 4.34,
  "ratingCount": 36279225,
  "reviewCount": 1851822,
  "installs": "1,000,000,000+",
  "minInstalls": 1000000000,
  "price": 0,
  "priceMicros": 0,
  "currency": "USD",
  "free": true,
  "containsAds": true,
  "appUrl": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "language": "en",
  "country": "US"
}
```

> Ratings, review counts, installs, prices, and other Google Play values can change over time.

***

### 🔎 Example search result

```json
{
  "mode": "search",
  "query": "spotify",
  "rank": 1,
  "packageId": "com.spotify.music",
  "appName": "Spotify: Music and Podcasts",
  "developerName": "Spotify AB",
  "rating": 4.34,
  "category": "Music & Audio",
  "price": 0,
  "priceMicros": 0,
  "currency": "USD",
  "free": true,
  "iconUrl": "https://play-lh.googleusercontent.com/...",
  "installs": "1,000,000,000+",
  "appUrl": "https://play.google.com/store/apps/details?id=com.spotify.music",
  "language": "en",
  "country": "US"
}
```

***

### 🏆 Observed Google Play rank

One of the most useful fields in search mode is:

```text
rank
```

This means:

> **The observed position of the app in Google Play results for that specific search term during the scrape.**

Example:

```text
Query: spotify

Spotify: Music and Podcasts → rank 1
Spotify: Music & Podcasts  → rank 2
Spotify for Artists         → rank 3
Spotify for Creators        → rank 4
Spotify Kids                → rank 5
```

Rank is based on the **order Google Play returned during that run**.

Google Play search results can change depending on:

- **Country**
- **Language**
- **Time**
- **Google Play ranking changes**
- **Search query**

> `rank` should be treated as an **observed search position**, not a permanent universal ranking.

***

### 🔍 Multiple search terms

Every search term keeps its own search context.

For example, the same application could appear as:

```text
Spotify
Query: music
Rank: 2
```

and:

```text
Spotify
Query: podcasts
Rank: 1
```

**Both rows are retained.**

This is intentional because they represent **two different Google Play search appearances**.

The Actor does **not globally deduplicate apps across different search queries**.

***

### 💰 Pricing

The Actor normalizes Google Play pricing into several fields.

Example paid application:

```text
price: 6.99
priceMicros: 6990000
currency: USD
free: false
```

Example free application:

```text
price: 0
priceMicros: 0
currency: USD
free: true
```

`priceMicros` represents Google's raw price value in **millionths of the currency unit**.

For example:

```text
6990000 micros
=
6.99 USD
```

The Actor uses the structured numeric price to determine **free vs paid status** rather than relying only on button text.

***

### 🌍 Regional pricing

Google Play pricing may vary by country.

For example, during testing the same Minecraft app returned:

```text
Country: US
Currency: USD
Price: $6.99
```

and:

```text
Country: PH
Currency: PHP
Price: ₱69.00
```

This makes country selection useful for:

- **Regional pricing research**
- **International app comparisons**
- **Market analysis**
- **Localization testing**

***

### 🌐 Language localization

Google Play may provide localized application data depending on the selected language.

For example:

```text
Language: en
Spotify: Music and Podcasts
Category: Music & Audio
```

versus:

```text
Language: es
Spotify: música y podcasts
Category: Música y audio
```

This can be useful for:

- **International ASO research**
- **Localized competitor analysis**
- **Translation monitoring**
- **Regional app research**

***

### ⚡ Performance

Google Play Store Scraper uses an **HTTP-first architecture**.

Instead of launching Chrome or another browser, it communicates directly with the structured Google Play web responses used by the store interface.

This provides:

```text
Fast startup
Low memory usage
Lower compute requirements
No browser overhead
Efficient batch app lookups
```

The current version starts conservatively with:

```text
App batch size: 3
Concurrent operations: 2
```

These values were chosen after successful testing from **Apify infrastructure**.

***

### 🛡 Reliability

**Temporary network failures and rate-limit responses are retried automatically with delays.**

The Actor also checks for Google challenge responses.

It does **not attempt to bypass Google challenges**.

If several independent searches are submitted and one fails, successful search results from the other terms can still remain in the Dataset.

If the entire run produces no results, the Actor fails instead of silently returning an empty successful run.

***

## 🔌 API & integrations

Google Play Store Scraper can be run programmatically through the **Apify API**.

Dataset results can be connected to workflows such as:

- Google Sheets
- Make
- Zapier
- CRMs
- Internal APIs
- Databases
- Data warehouses
- AI agents
- MCP workflows
- App intelligence dashboards

Every run produces **structured Dataset rows**, making the scraper suitable for automated data pipelines.

***

## 💡 Example use cases

#### 📊 Competitor research

Compare competing applications using:

```text
Rating
Rating count
Review count
Installs
Category
Pricing
Developer
```

***

#### 🔎 App keyword research

Search keywords such as:

```text
photo editor
VPN
budget planner
AI chatbot
fitness tracker
```

and analyze:

```text
Which apps rank highest
Which developers appear repeatedly
Ratings
Install counts
Categories
Free vs paid apps
```

***

#### 🏆 Google Play ranking research

Track the observed rank for applications across different queries.

Example:

```text
Query: music
App: Spotify
Rank: 2
```

```text
Query: podcasts
App: Spotify
Rank: 1
```

Because each query is stored separately, search visibility can be analyzed without losing provenance.

***

#### 🌎 Regional price research

Run the same app with different countries to compare:

```text
Currency
Price
Free / paid status
Regional Google Play values
```

***

#### 🌐 Localization research

Compare an application's:

```text
Title
Description
Category
Pricing context
```

across different Google Play languages and countries.

***

#### 🧑‍💻 Developer research

Collect available developer information such as:

```text
Developer name
Developer ID
Developer website
Developer email
Google Play developer URL
```

for app research or market analysis.

***

## ⚠️ Current limitations

The current version focuses on **fast and reliable Google Play app details and keyword search**.

It does **not currently perform**:

```text
Deep search pagination
Review extraction
Developer catalog crawling
Category chart crawling
Permission extraction
Full Data Safety extraction
Browser-based crawling
```

Search mode uses **Google Play's initial ranked app cluster only**.

Because Google Play controls the number of results exposed for each search, requesting 30 results does **not guarantee 30 results**.

***

## ❓ FAQ

### Do I need a Google API key?

**No.**

The Actor does not require a Google developer API key.

***

### Is a browser required?

**No.**

The current scraper uses lightweight HTTP requests and structured Google Play web responses.

It does not normally launch:

```text
Chrome
Playwright
Puppeteer
```

***

### Can I scrape paid apps?

**Yes.**

Paid applications include normalized fields such as:

```text
price
priceMicros
currency
free
```

***

### Can I submit Google Play URLs instead of package IDs?

**Yes.**

Both formats are supported:

```text
com.spotify.music
```

and:

```text
https://play.google.com/store/apps/details?id=com.spotify.music
```

***

### Can I search multiple keywords?

**Yes.**

Each search term is processed independently.

Example:

```text
music
podcasts
audio player
```

Each query receives its own ranked results.

***

### How many search results can I scrape?

The current setting supports:

```text
Maximum: 30 results per search term
```

However, Google Play often exposes fewer results in its initial ranked cluster.

For example, a request for:

```text
30 results
```

may return:

```text
18 results
```

if that is all Google Play exposes on the current search surface.

***

### Why can the same app appear more than once?

Because the same app may rank for **multiple search terms**.

Example:

```text
Spotify
Query: music
Rank: 2
```

and:

```text
Spotify
Query: podcasts
Rank: 1
```

These are different search observations, so **both rows are intentionally preserved**.

***

### Does country affect pricing?

**Yes.**

Google Play can return different currencies and prices for different countries.

Use the `country` input to choose the target market.

***

### Does language affect app information?

**Yes.**

When Google provides translations, changing `language` can affect:

```text
App name
Description
Short description
Category
```

***

### Can I export the results?

**Yes.**

Apify Dataset results can be exported in supported formats such as:

```text
JSON
CSV
Excel
XML
HTML
```

They can also be accessed programmatically through the **Apify API**.

***

### Does the Actor scrape reviews?

**Not in the current version.**

Review extraction is intentionally kept separate from this V1 so the main Actor remains fast and focused on:

```text
App details
Search results
Rank
Pricing
Localization
Developer information
```

***

## 💬 Feedback & support

Found a bug or have a feature request?

Use the Actor's **Issues** tab on Apify.

Useful future additions may include:

```text
Google Play reviews
Developer app listings
Categories and charts
Permissions
Data Safety information
Additional app metadata
```

When reporting a problem, include:

```text
Actor run ID
Input used
Package ID or search term
Country
Language
```

This makes troubleshooting much faster.

***

### 🚀 Google Play app data without manual searching

Enter **app package IDs, Google Play URLs, or search terms**, choose your **country and language**, run the Actor, and receive **structured Google Play data** ready for:

**app research, competitor analysis, keyword tracking, regional pricing research, APIs, and automation.**

# Actor input Schema

## `packageIdsOrUrls` (type: `array`):

Enter Google Play package IDs or full Google Play app URLs. Each app is fetched independently. Example package ID: com.spotify.music

## `searchTerms` (type: `array`):

Search Google Play for apps. Each term is searched independently and results preserve the Google Play ranking for that query.

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

Two-letter Google Play country code used for regional availability and pricing. Examples: US, PH, GB, CA, AU.

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

Google Play language code used for localized titles, categories and descriptions. Examples: en, es, de, fr.

## `maxResultsPerSearch` (type: `integer`):

Maximum number of ranked apps to save for each search term. Google Play may return fewer results because V1 uses only Google's initial ranked search cluster.

## Actor input object example

```json
{
  "packageIdsOrUrls": [
    "com.spotify.music"
  ],
  "searchTerms": [
    "spotify"
  ],
  "country": "US",
  "language": "en",
  "maxResultsPerSearch": 20
}
```

# Actor output Schema

## `results` (type: `string`):

App details and ranked Google Play search results.

# 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 = {
    "packageIdsOrUrls": [
        "com.spotify.music"
    ],
    "searchTerms": [
        "spotify"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("aerodynamic_tripod/my-actor").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 = {
    "packageIdsOrUrls": ["com.spotify.music"],
    "searchTerms": ["spotify"],
}

# Run the Actor and wait for it to finish
run = client.actor("aerodynamic_tripod/my-actor").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 '{
  "packageIdsOrUrls": [
    "com.spotify.music"
  ],
  "searchTerms": [
    "spotify"
  ]
}' |
apify call aerodynamic_tripod/my-actor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,aerodynamic_tripod/my-actor"
        }
    }
}
```

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/AfIYdeZvLryUFHw40/builds/Pbgru0tVzbew9IzqT/openapi.json