# App Intelligence · App Store & Google Play Search, Charts (`agentsgearbox/app-intelligence`) Actor

App Store and Google Play in one run: search both stores, top charts by country and category, full app details (ratings, installs, price, version, developer), similar apps, and each app's iOS or Android twin with a confidence score. No login. $1.80 per 1,000 apps; first 25 apps each month free.

- **URL**: https://apify.com/agentsgearbox/app-intelligence.md
- **Developed by:** [AgentsGearbox](https://apify.com/agentsgearbox) (community)
- **Categories:** E-commerce, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.08 / 1,000 apps

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

## App Intelligence · App Store and Google Play in one run

Search both stores, pull the top charts by country, look up any app by id, URL or bundle id, and get the full details (ratings and counts, installs, price, version, release and update dates, content rating, in-app purchases, developer contact). Then the part nobody else does: every app comes with its **twin on the other store**, matched by title and developer with a confidence score, so you can compare an app's iOS and Android presence side by side. No login, no proxies, pay per app. The first 25 apps each month are free for every account.

Built by [agentsgearbox](https://agentsgearbox.com). Questions: support@agentsgearbox.com.

### What you get

One `app` item per app, store and country. A real row from the US "top free" chart, shortened:

```json
{
  "store": "google-play",
  "country": "us",
  "source": "chart",
  "chart": "top-free",
  "category": "all",
  "rank": 2,
  "appId": "com.openai.chatgpt",
  "title": "ChatGPT",
  "developer": "OpenAI",
  "developerId": "OpenAI",
  "developerUrl": "https://openai.com",
  "developerEmail": "support@openai.com",
  "rating": 4.78,
  "ratings": 64896914,
  "reviewsCount": 1952880,
  "histogram": { "1": 2127661, "2": 668224, "3": 1699700, "4": 5263590, "5": 55137739 },
  "price": 0,
  "currency": "USD",
  "free": true,
  "genre": "Productivity",
  "installs": "1,000,000,000+",
  "minInstalls": 1000000000,
  "version": "1.2026.282",
  "released": "Jul 25, 2023",
  "updated": "2026-10-11T18:40:12.000Z",
  "contentRating": "Everyone",
  "androidVersion": "8.0",
  "adSupported": false,
  "offersIAP": true,
  "iapRange": "$8.99 - $200.00 per item",
  "icon": "https://play-lh.googleusercontent.com/…",
  "url": "https://play.google.com/store/apps/details?id=com.openai.chatgpt&hl=en&gl=us",
  "twinStore": "app-store",
  "twinAppId": "6448311069",
  "twinTitle": "ChatGPT",
  "twinDeveloper": "OpenAI OpCo, LLC",
  "twinRating": 4.83,
  "twinRatings": 11377787,
  "twinUrl": "https://apps.apple.com/us/app/chatgpt/id6448311069",
  "twinConfidence": 0.87,
  "fetchedAt": "2026-10-17T16:02:41.512Z"
}
```

App Store rows carry the same fields where Apple publishes them (no install counts, but `ratingCurrentVersion`, `minOs`, `sizeBytes`, `languages`); `source` is `search`, `chart`, `lookup` or `twin`. Plus one free `summary` item per run and a free `error` item for ids that exist in neither store or charts that are unavailable.

### What it can do

| Job | Google Play | App Store |
|---|---|---|
| Search by keyword, per country and language | up to 100 results per query | up to 200 results per query |
| Top charts per country | top free, top paid, top grossing, overall or by category (GAME, FINANCE, …) | top free, top paid, overall (Apple's public feed has no category filter) |
| Look up apps | package name or store URL, with "similar apps" on request | numeric id, store URL or bundle id |
| Full details on every row | ratings histogram, installs, version, dates, IAP range, developer email and site | ratings, current-version rating, version, dates, size, minimum OS, languages |
| Twin on the other store | iOS twin for every Android app | Android twin for every iOS app |

Twin matching scores title similarity (60%), developer similarity (40%) and a bonus when both developers link the same website; matches below 0.55 are left empty rather than guessed.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | string\[] | – | Search terms, run in each store and country. |
| `appIds` | string\[] | – | Package names, App Store ids, bundle ids or store URLs. |
| `charts` | string\[] | – | `top-free`, `top-paid`, `top-grossing` (Google Play only). |
| `chartCategories` | string\[] | – | Google Play categories for the charts; empty = overall. |
| `chartSize` | integer | `50` | Apps per chart, up to 200. |
| `stores` | string\[] | both | `google-play`, `app-store`. |
| `countries` | string\[] | `["us"]` | Two-letter store countries; everything runs once per country. |
| `language` | string | `en` | Language of Google Play titles and descriptions. |
| `maxResultsPerQuery` | integer | `20` | Results per search query, store and country. |
| `includeDetails` | boolean | `true` | Full details for apps from searches and charts. |
| `findTwins` | boolean | `true` | Match each app's twin on the other store (both stores selected). |
| `includeSimilar` | boolean | `false` | Google Play "similar apps" for apps looked up by id. |
| `includeDescription` | boolean | `false` | Full description text (long). |

At least one of `searchQueries`, `appIds` or `charts` is required. An app that appears in several sources (a search and a chart, say) is returned once per store and country, from the first source that found it.

### Pricing

**Try it free.** The first 25 apps each calendar month are free for every Apify account, with nothing to enter: the actor keeps count in a small key-value store in your account (`free-slice-app-intelligence`) and charges only from the 26th on. The free results are real results you keep; the counter resets on the first of each month.

Pay per event: **$0.0018 per app** (`app`), that is $1.80 per 1,000 apps, 40% under the most used app-search actor on the Store. Twin matching, summary and error records are free. Apify plans above Free get an automatic discount on every event (10% to 40%).

| Run | Apps | Cost |
|---|---|---|
| One keyword, both stores, 20 results each, with twins | 40 | $0.07 |
| Top 100 free apps, both stores, 5 countries, full details | 1,000 | $1.80 |
| Look up 500 competitor apps with their twins | 500 | $0.90 |

Apple's Search API allows about 20 calls a minute per address, so App Store work is rate-limited inside the actor: searches and twin lookups on large runs take a few minutes rather than seconds. Chart details are batched (100 apps per call), so charts stay fast.

### Example tasks

Ready-made configurations you can open, copy and run as they are:

- [Top free apps on App Store and Google Play, with their twins](https://apify.com/agentsgearbox/app-intelligence/examples/top-free-apps-on-both-stores-with-twins): the top 25 free apps of both US stores with full details and each app's twin on the other platform.

### Run it from your code

**Node.js**

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('agentsgearbox/app-intelligence').call({ searchQueries: ['budget tracker'], countries: ['us', 'gb'], maxResultsPerQuery: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const a of items.filter((i) => i.type === 'app')) console.log(a.store, a.country, a.rank, a.title, a.rating, a.ratings, a.twinTitle, a.twinConfidence);
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient(token=os.environ["APIFY_TOKEN"])
run = client.actor("agentsgearbox/app-intelligence").call(run_input={"charts": ["top-free"], "chartSize": 50, "countries": ["us"]})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("type") == "app":
        print(item["store"], item["rank"], item["title"], item["installs"], item.get("twinTitle"))
```

**cURL**

```bash
curl -s -X POST "https://api.apify.com/v2/acts/agentsgearbox~app-intelligence/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' -d '{"appIds":["com.whatsapp","https://apps.apple.com/us/app/id1232780281"],"countries":["us"]}'
```

### For AI agents

Give your agent hands. "Which apps compete with X, how are they rated, and do they exist on both platforms?" becomes one tool call instead of two store searches, dozens of page fetches and a guess at which Android app is the iOS one. A human analyst spends half an hour on a ten-app comparison; this actor returns it in under a minute for a few cents.

- **MCP, this actor only:** add `https://mcp.apify.com?tools=agentsgearbox/app-intelligence` to Claude Desktop, Claude Code, Cursor or any MCP client (with your Apify token), then ask for "the top 20 free finance apps in Germany on both stores with ratings and their twins".

* **MCP, all agentsgearbox actors:** `https://mcp.apify.com?tools=agentsgearbox/telegram-channel-scraper,agentsgearbox/google-play-reviews-scraper,agentsgearbox/substack-scraper,agentsgearbox/google-news-scraper,agentsgearbox/brand-name-generator,agentsgearbox/ai-readiness-audit,agentsgearbox/company-lookup,agentsgearbox/app-intelligence,agentsgearbox/app-store-reviews-scraper`

- **No Apify account?** This actor is eligible for Apify's agentic payments: an agent can buy a spend-capped token through [agi.apify.com](https://agi.apify.com) (x402, MPP or Skyfire) and call the API directly.
- Prices are per result and known in advance; missing apps and unavailable charts come back as free error records instead of failed runs.

### Reading the results

- `installs` exists only on Google Play (Apple does not publish downloads); use `ratings` to compare popularity across stores.
- `twinConfidence` of 1 means identical title and developer; 0.6 to 0.85 usually means the same app with a differently worded title; below 0.55 nothing is returned.
- `source: "lookup"` rows have no `rank`; chart rows carry `chart`, `category` and `rank`; search rows carry `query` and `rank`.
- Dates come as the stores give them: ISO timestamps for Google Play updates, Apple's ISO dates, and Google Play's human-readable `released` string.

### Limitations, stated plainly

- Apple publishes no install or download numbers and no category filter on its public chart feed; top grossing exists only on Google Play. Asking for an App Store category or grossing chart adds a free `error` row that says so, and the Google Play side of the request still runs.
- App Store search is fuzzy on Apple's side: a nonsense or very rare query can still return loosely matched apps instead of nothing. Check `title` and `developer` before trusting a hit.
- Google Play has no official API; details come from the store's web pages through a maintained open-source parser and may need a same-day fix when Google changes the page. Our daily platform test catches that.
- Reviews are a separate job: use our Google Play Reviews Scraper for review text; App Store reviews are not covered here.
- Apple's Search API rate limit (about 20 calls a minute per address) bounds how fast large App Store searches and twin matching can run.

### Troubleshooting

| Symptom | Cause | Fix |
|---|---|---|
| Fewer App Store results than requested | Apple returns at most 200 per query and fewer for narrow terms | Expected |
| `twinTitle: null` | No app on the other store scored 0.55 or higher | The app may be exclusive to one platform; check manually if it matters |
| Error `not found in this country's store` | The app is not published in that country | Try the app's home country |
| Slow run with many App Store twins | Apple's rate limit | Run fewer queries per run or disable `findTwins` for bulk pulls |

### More from agentsgearbox

- [Telegram Channel Scraper](https://apify.com/agentsgearbox/telegram-channel-scraper): public Telegram channels as JSON, no API key.
- [Google Play Reviews Scraper](https://apify.com/agentsgearbox/google-play-reviews-scraper): Google Play reviews with replies and versions, any market.
- [Substack Scraper](https://apify.com/agentsgearbox/substack-scraper): Substack posts with full text and comments, custom domains too.
- [Google News Scraper](https://apify.com/agentsgearbox/google-news-scraper): Google News with real publisher URLs and full text.
- [Brand & Business Name Generator](https://apify.com/agentsgearbox/brand-name-generator): brand names verified live on domains, handles and app stores.
- [AI Readiness Audit](https://apify.com/agentsgearbox/ai-readiness-audit): how well AI search engines and agents can read a site: crawler access, llms.txt, structured data, content without JavaScript, scored with fixes.
- [Company Lookup](https://apify.com/agentsgearbox/company-lookup): one row per domain with legal identity and VAT validation, contacts, socials, tech stack, open jobs, apps, news and Wikidata facts.
- [App Store Reviews Scraper · iOS + Google Play, Any Country](https://apify.com/agentsgearbox/app-store-reviews-scraper): Reviews of any iOS or Android app from both stores in one run: stars, text, version, votes, developer replies, since-last-run checkpoint, rating trend per app..

All of them are pay-per-event, run without a browser, and are compared with their alternatives on [agentsgearbox.com](https://agentsgearbox.com/actors/).

### Support

Email support@agentsgearbox.com or use the issues tab. Compare this actor with alternatives on [agentsgearbox.com](https://agentsgearbox.com).

# Actor input Schema

## `searchQueries` (type: `array`):

Search terms to run in the selected stores (e.g. "budget tracker", "meditation"). Each query returns up to maxResultsPerQuery apps per store and country.

## `appIds` (type: `array`):

Google Play package names (com.whatsapp), App Store numeric ids (310633997), bundle ids (net.whatsapp.WhatsApp) or store URLs. Each gets full details, and its twin on the other store when findTwins is on.

## `charts` (type: `array`):

Charts to fetch per store and country. Google Play: top free, top paid, top grossing (optionally within a category). App Store: top free and top paid, overall.

## `chartCategories` (type: `array`):

Optional Google Play categories for the charts (GAME, FINANCE, HEALTH_AND_FITNESS, PRODUCTIVITY, SHOPPING, …). Apple’s public chart feed has no category filter, so App Store charts are always the overall charts. Leave empty for overall charts on both stores.

## `chartSize` (type: `integer`):

How many apps to take from each chart (max 200).

## `stores` (type: `array`):

Which stores to query.

## `countries` (type: `array`):

Two-letter store countries (us, gb, de, it, br, in, jp …). Searches, charts and lookups run once per country.

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

Language of titles and descriptions where the store supports it (Google Play).

## `maxResultsPerQuery` (type: `integer`):

Apps returned per query, store and country.

## `includeDetails` (type: `boolean`):

Adds ratings histogram, installs, version, release and update dates, content rating, in-app purchases, developer contact and the full description to every app found by search or charts. Costs one extra request per app on Google Play; App Store details are batched.

## `findTwins` (type: `boolean`):

Searches the other store by title and developer and attaches the best match with a confidence score (0-1). Only when both stores are selected.

## `includeSimilar` (type: `boolean`):

Adds the Google Play 'similar apps' list for apps looked up by id.

## `includeDescription` (type: `boolean`):

Adds the complete store description to detail rows (can be long).

## Actor input object example

```json
{
  "searchQueries": [
    "budget tracker"
  ],
  "appIds": [
    "com.whatsapp",
    "https://apps.apple.com/us/app/notion-notes-docs-tasks/id1232780281"
  ],
  "charts": [],
  "chartSize": 50,
  "stores": [
    "google-play",
    "app-store"
  ],
  "countries": [
    "us"
  ],
  "language": "en",
  "maxResultsPerQuery": 20,
  "includeDetails": true,
  "findTwins": true,
  "includeSimilar": false,
  "includeDescription": false
}
```

# Actor output Schema

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

One item per app (search result, chart entry or details) with store, country and twin match, plus one free summary item.

# 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 = {
    "searchQueries": [
        "budget tracker"
    ],
    "appIds": [
        "com.whatsapp",
        "https://apps.apple.com/us/app/notion-notes-docs-tasks/id1232780281"
    ],
    "stores": [
        "google-play",
        "app-store"
    ],
    "countries": [
        "us"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("agentsgearbox/app-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 = {
    "searchQueries": ["budget tracker"],
    "appIds": [
        "com.whatsapp",
        "https://apps.apple.com/us/app/notion-notes-docs-tasks/id1232780281",
    ],
    "stores": [
        "google-play",
        "app-store",
    ],
    "countries": ["us"],
}

# Run the Actor and wait for it to finish
run = client.actor("agentsgearbox/app-intelligence").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 '{
  "searchQueries": [
    "budget tracker"
  ],
  "appIds": [
    "com.whatsapp",
    "https://apps.apple.com/us/app/notion-notes-docs-tasks/id1232780281"
  ],
  "stores": [
    "google-play",
    "app-store"
  ],
  "countries": [
    "us"
  ]
}' |
apify call agentsgearbox/app-intelligence --silent --output-dataset

```

## MCP server setup

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

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/a1iGraSLdv67KGlTT/builds/kAPimmLFDLE8aU7MT/openapi.json