DEV Community

KazKN
KazKN

Posted on • Edited on

How to Monitor App Store Rankings Daily With Apify

#webscraping #tutorial #api #automation

You Can't Improve What You Don't Measure

App Store rankings change every day. An app that was #3 in Health & Fitness yesterday might be #8 today. A competitor might launch a new version that leapfrogs your position overnight.

If you're not tracking these changes daily, you're flying blind.

I learned this the hard way. I was manually checking 50 apps across 40 countries every Monday morning. By the time I updated my spreadsheet, the data was already stale. Rankings had shifted. New apps had appeared. My "weekly snapshot" was a fiction.

So I automated it. Here's exactly how to set up daily App Store ranking monitoring using Apify — with zero manual work after the initial setup.

Why Daily Ranking Monitoring Matters

According to our analysis of 10,000+ apps using the Apple App Store Localization Scraper:

  • 67% of apps experience ranking fluctuations of ±5 positions within a single week
  • 23% of apps drop out of the top 50 within a month of entering it
  • Top 10 positions account for 78% of organic downloads in any category
  • Apps that respond to ranking drops within 48 hours recover 3x faster than those that wait

Daily monitoring isn't a nice-to-have. It's survival.

The Architecture: Scrape → Store → Alert

Here's the system we'll build:

[Apify Scheduler] → [App Store Scraper] → [Dataset] → [Webhook] → [Your Dashboard/Alerts]
       ↓                                                              ↓
  Runs daily at 6 AM                                         Slack/Email/SMS
Enter fullscreen mode Exit fullscreen mode

Components:

  1. Apify Actor: The Apple App Store Localization Scraper extracts ranking data
  2. Apify Scheduler: Triggers the scraper daily
  3. Apify Dataset: Stores historical data
  4. Webhook/Integration: Sends alerts on ranking changes

Step 1: Define What to Track

Before automating, decide your scope:

{
  "searchTerms": [
    "meditation app",
    "mindfulness",
    "calm meditation",
    "sleep sounds"
  ],
  "countries": ["us", "gb", "fr", "de", "au", "ca"],
  "maxResults": 50
}
Enter fullscreen mode Exit fullscreen mode

Pro tip: Include your own brand name and competitor brand names in the search terms to track branded keyword rankings.

Step 2: Create Your First Monitoring Run

Using curl: 

curl -X POST "https://api.apify.com/v2/acts/kazkn~apple-app-store-localization-scraper/runs" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "searchTerms": ["meditation app", "mindfulness"],
    "countries": ["us", "gb", "fr", "de"],
    "maxResults": 50
  }'
Enter fullscreen mode Exit fullscreen mode

Using Node.js: 

const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

async function monitorRankings() {
    const run = await client.actor('kazkn/apple-app-store-localization-scraper').call({
        searchTerms: ['meditation app', 'mindfulness', 'calm meditation'],
        countries: ['us', 'gb', 'fr', 'de', 'au', 'ca'],
        maxResults: 50,
    });

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

    // Add timestamp and ranking position
    const ranked = items.map((item, index) => ({
        ...item,
        scrapedAt: new Date().toISOString(),
        rankPosition: index + 1,
    }));

    return ranked;
}
Enter fullscreen mode Exit fullscreen mode

Step 3: Set Up the Apify Scheduler

  1. Go to Apify Console
  2. Navigate to Schedules → Create new
  3. Select your actor: kazkn/apple-app-store-localization-scraper
  4. Set the cron expression: 0 6 * * * (daily at 6 AM UTC)
  5. Paste your input configuration
  6. Save

That's it. Every morning at 6 AM, fresh ranking data is waiting for you.

Step 4: Build a Ranking History Database

To track changes over time, push each day's data to a named dataset:

from apify_client import ApifyClient
from datetime import datetime
import json

client = ApifyClient('YOUR_API_TOKEN')

def store_daily_rankings():
    # Run the scraper
    run = client.actor('kazkn/apple-app-store-localization-scraper').call(run_input={
        'searchTerms': ['meditation app', 'mindfulness'],
        'countries': ['us', 'fr', 'de'],
        'maxResults': 50,
    })

    items = list(client.dataset(run['defaultDatasetId']).iterate_items())

    # Add date stamp
    today = datetime.now().strftime('%Y-%m-%d')
    for i, item in enumerate(items):
        item['date'] = today
        item['rank'] = i + 1

    # Push to a persistent named dataset
    named_dataset = client.datasets().get_or_create(name='app-store-rankings-history')
    dataset_client = client.dataset(named_dataset['id'])
    dataset_client.push_items(items)

    print(f'Stored {len(items)} rankings for {today}')
    return items

store_daily_rankings()
Enter fullscreen mode Exit fullscreen mode

Step 5: Detect Ranking Changes and Send Alerts 

import requests

def check_ranking_changes(today_data, yesterday_data, threshold=3):
    """Alert when any tracked app moves more than `threshold` positions."""

    alerts = []
    today_ranks = {item['appId']: item for item in today_data}
    yesterday_ranks = {item['appId']: item for item in yesterday_data}

    for app_id, today_app in today_ranks.items():
        if app_id in yesterday_ranks:
            yesterday_rank = yesterday_ranks[app_id]['rank']
            today_rank = today_app['rank']
            change = yesterday_rank - today_rank  # positive = improved

            if abs(change) >= threshold:
                direction = '📈' if change > 0 else '📉'
                alerts.append({
                    'app': today_app['appName'],
                    'country': today_app['country'],
                    'change': change,
                    'direction': direction,
                    'new_rank': today_rank,
                })

    if alerts:
        message = '🚨 App Store Ranking Changes:\n\n'
        for alert in alerts:
            message += f"{alert['direction']} {alert['app']} ({alert['country'].upper()}): "
            message += f"#{alert['new_rank']} ({'+' if alert['change'] > 0 else ''}{alert['change']})\n"

        # Send to Slack
        requests.post('YOUR_SLACK_WEBHOOK', json={'text': message})

        # Or send email via your preferred service
        print(message)

    return alerts
Enter fullscreen mode Exit fullscreen mode

Sample alert:

🚨 App Store Ranking Changes:

📉 Calm (US): #5 (-3)
📈 Headspace (FR): #2 (+4)
📈 MindfulMe (DE): #8 (+7)
Enter fullscreen mode Exit fullscreen mode

Step 6: Build a Simple Dashboard

Export your historical data as CSV and visualize with any tool:

# Download all historical ranking data
curl "https://api.apify.com/v2/datasets/YOUR_DATASET_ID/items?format=csv" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -o rankings_history.csv
Enter fullscreen mode Exit fullscreen mode

Load into Google Sheets, Tableau, or even matplotlib:

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv('rankings_history.csv')

# Plot ranking over time for top apps
for app_name in ['Calm', 'Headspace', 'Insight Timer']:
    app_data = df[(df['appName'] == app_name) & (df['country'] == 'us')]
    plt.plot(app_data['date'], app_data['rank'], label=app_name)

plt.gca().invert_yaxis()  # Lower rank number = better
plt.xlabel('Date')
plt.ylabel('Ranking Position')
plt.title('US App Store Rankings: Meditation Apps')
plt.legend()
plt.savefig('ranking_chart.png')
Enter fullscreen mode Exit fullscreen mode

Step 7: Multi-Country Ranking Comparison

The killer feature of the Apple App Store Localization Scraper is cross-country analysis. You can compare how the same app ranks across markets:

async function crossCountryRankings(appName) {
    const run = await client.actor('kazkn/apple-app-store-localization-scraper').call({
        searchTerms: [appName],
        countries: ['us', 'gb', 'fr', 'de', 'es', 'it', 'jp', 'kr', 'br', 'au'],
        maxResults: 50,
    });

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

    const appResults = items.filter(i => 
        i.appName.toLowerCase().includes(appName.toLowerCase())
    );

    console.log(`\nRankings for "${appName}" across countries:`);
    appResults.forEach(app => {
        console.log(`  ${app.country.toUpperCase()}: #${app.rank || 'N/A'} — ${app.rating}★ (${app.ratingCount} ratings)`);
    });
}

crossCountryRankings('Headspace');
Enter fullscreen mode Exit fullscreen mode

Based on data from the Apple App Store Scraper by kazkn, apps that rank Top 10 in the US but below #50 in France represent prime localization opportunities.

Bonus: Integrate With Other Data Sources

Combine App Store data with e-commerce trends. For example, use the Vinted Smart Scraper to track fashion app popularity alongside Vinted marketplace trends. The Vinted MCP Server (also on npm and GitHub) lets you query Vinted data using AI — perfect for cross-referencing market trends.

FAQ

How much does daily monitoring cost on Apify?

With the free tier, you can run small daily scrapes (20-50 apps, 2-3 countries). For broader monitoring (100+ apps, 10+ countries), the paid plans start at a few dollars per month. The ROI is massive compared to manual research.

Can I monitor rankings for specific keywords, not just app names?

Yes. Set searchTerms to any keyword (e.g., "budget planner") and the scraper returns all matching apps ranked by relevance — effectively giving you keyword ranking data.

How accurate is the ranking data compared to App Store Connect?

The scraper reflects what a user would see when searching the App Store. This may differ slightly from App Store Connect analytics, which include impression and download data. Both perspectives are valuable.

Can I track ranking changes across different App Store categories?

Yes. Run separate scrapes for different categories by using category-specific search terms. For example, "fitness tracker" for Health & Fitness, "todo list" for Productivity.

What's the best time of day to scrape rankings?

Early morning (6-8 AM UTC) captures the previous day's final rankings before the daily refresh cycle. Consistency matters more than the exact time — always scrape at the same hour for comparable data.

Stop Guessing, Start Monitoring

Ranking drops don't announce themselves. By the time you notice manually, you've already lost downloads. Daily automated monitoring gives you the data to react fast.

👉 Set up daily App Store monitoring now

Free to start. Your first ranking report in under 5 minutes.

By kazkn — building app store intelligence tools for developers and marketers.

Top comments (0)