# App Store New Apps Scraper: iOS Publisher Leads (`moggedhq/app-store-new-apps`) Actor

Find newly released iPhone apps for app-growth sales and investor research. Get each app's first release date, publisher, category, App Store link and website when Apple provides it. About $0.0026 per app, or $0.26 for 100. No account or API key. Daily feeds with deduplication.

- **URL**: https://apify.com/moggedhq/app-store-new-apps.md
- **Developed by:** [mogged](https://apify.com/moggedhq) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.08 / 1,000 new 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 Store New Apps Scraper: iOS Publisher Leads

For app-growth agencies and investors who want newly released iPhone apps, their dated first releases, publishers and source links without collecting app IDs first. About **$0.0026 per verified new app**, or **$0.26 for 100 apps**, plus the minimum $0.00005 Actor start charge. No Apple account or API key is needed.

Each row gives the app, publisher, original release date and source URLs. Websites appear only when Apple supplies them. Coverage is limited to public rolling feeds, not every App Store launch.

### What counts as new

The Actor reads Apple's `newapplications` feed for each selected storefront. It parses the original release timestamp, excludes dates outside your requested window, removes duplicate app IDs and checks the remaining apps through Apple's public lookup endpoint. The lookup's `releaseDate` must agree with the feed. A recent `currentVersionReleaseDate` does not make an older app a new launch.

`dateVerified: true` means the original date was confirmed against Apple's lookup data. It does not mean an independent investigation established when the business opened, when development began or when the product first launched anywhere in the world. Dates can differ between storefronts. Conflicting feed and lookup dates are excluded without an app charge.

Publishers can be individuals or companies. `publisherName` is Apple's artist/publisher label, and `publisherType` remains `unknown`. The Actor does not infer corporate status from a business-sounding name or identify founders. There is no verified-company-only filter, email extraction or guessed domain enrichment.

### What you get

| Field | Meaning |
| --- | --- |
| `verdict` | Readable lead summary: app, publisher, dated release, stores, price and website availability. |
| `appId` | Stable App Store app ID, stored as text. One paid row per distinct ID. |
| `appName` | App name returned by the country-specific lookup. |
| `publisherName` | Apple's publisher/artist name; not a verified company identity. |
| `publisherId` | Apple's publisher ID when supplied, otherwise null. |
| `publisherType` | Always `unknown`; no corporate verification is performed. |
| `originalReleaseDate` | Original release timestamp in UTC, confirmed against lookup data. |
| `currentVersionReleaseDate` | Latest version timestamp when present; never used as the first-release date. |
| `observedAt` | When the verified record was collected. This is not a launch date. |
| `availableCountries` | Queried feed storefronts containing the qualifying app. Not worldwide availability. |
| `category` | Primary Apple category, such as Productivity or Shopping. |
| `categoryId` | Primary Apple category ID as text. |
| `price` | Numeric price in the lookup storefront, or null when absent. Zero means free. |
| `currency` | Supplied currency code, or null. |
| `priceCountry` | Storefront used for the returned price and lookup details. |
| `appStoreUrl` | Link to the app's App Store page. |
| `publisherWebsite` | Apple's supplied `sellerUrl`, or null. It is not guessed or independently checked. |
| `sourceUrls` | Public feed and individual lookup URLs for inspection. |
| `dateVerified` | True for delivered app rows that passed original-date validation. |
| `coverageNote` | Explanation of the evidence and limits for this record. |

The default dataset contains app rows. Its publisher view puts publisher identity first for review. The free `PUBLISHERS` output groups those same apps into one record per publisher, and `OUTPUT` links to a separate grouped dataset. Grouping is free and reduces repetitive outreach.

Every run also saves `SUMMARY`: queried countries, fixed date window, stale and failed feeds, old/future/duplicate exclusions, lookup exclusions, output count and spending-limit status. Empty runs still have a summary. A correct zero-result response means no qualifying records were available for your filters; it does not prove no apps launched.

### Start in three steps

1. Select storefronts and a first-release window. The default is `us` and `7 days`.
2. Set `maxApps`. The form's five-app prefill is a quick first check; the runtime default is 25.
3. Run the Actor, inspect the summary and export the app dataset or publisher groups.

The initial five-app US cloud test on 15 October 2026 completed in 7.4 seconds. It read 110 feed entries, excluded four future-dated entries and delivered exactly five verified apps. Apple's feed URL includes `limit=10`, but the actual feed ignored that as a strict cap. The Actor enforces its own output limit.

### Inputs and examples

| Input | Default | How to use it |
| --- | --- | --- |
| `countries` | `["us"]` | List of tested two-letter storefront codes. Duplicate codes are removed. |
| `since` | `"7 days"` | Date, timezone-aware timestamp, `today`, `yesterday`, or a duration such as `2 weeks`. |
| `maxApps` | `25` | Maximum distinct delivered apps, from 1 to 1,000. Prefill is 5. |
| `keywords` | none | Case-insensitive OR substring matches in app name, publisher or category. |
| `categories` | none | OR matches against exact primary category names or numeric IDs. |
| `excludeGames` | `false` | Exclude the Games category and apps whose lookup genres include Games. |
| `publisherTypes` | `"any"` | Only `any` is supported; publisher type remains unknown. |
| `skipPreviouslyDelivered` | `false` | Enable persistent app-ID deduplication across sequential runs of one watch. |
| `watchId` | `"default"` | Stable delivery-history name. Use separate names for separate prospecting lists. |
| `appIds` | none | Optional known-ID verification instead of feed discovery, using the first country. |

Relative durations start at midnight UTC that many days before the run. A plain date also starts at midnight UTC. The upper bound is the run's initial timestamp. Both bounds remain fixed if the run restarts. A wider window does not retrieve archived feed entries that Apple no longer exposes.

Keywords and categories filter the available feed; they do not search the complete App Store catalogue. For example, `keywords: ["fitness", "training"]` keeps a record matching either word. Combining that with a category filter requires both filter groups to match. A narrow filter can legitimately produce no rows.

```json
{
  "countries": ["us", "gb", "ca"],
  "since": "7 days",
  "maxApps": 100,
  "excludeGames": true
}
```

For a daily prospecting task, use a stable watch name and schedule sequential runs:

```json
{
  "countries": ["us"],
  "since": "7 days",
  "maxApps": 100,
  "skipPreviouslyDelivered": true,
  "watchId": "agency-us"
}
```

Run each watch sequentially. An unfinished previous run produces a free watch-busy summary; resume that original run before reusing the watch. Separate watch IDs keep separate histories; changing the ID can return and charge previously delivered apps again.

### Storefront coverage

The tested codes are `us`, `gb`, `ca`, `au`, `de`, `fr`, `es`, `it`, `nl`, `se`, `no`, `dk`, `fi`, `ie`, `nz`, `za`, `in`, `jp`, `kr` and `br`.

In the 15 October 2026 source test, 13 of 20 feeds contained qualifying records for the October 8-15 window. All 20 returned structured data. Seven were stale for that window. A feed can respond normally while listing old apps, so HTTP success alone does not establish freshness. Fresh storefronts were US, GB, CA, DE, FR, NL, SE, DK, FI, IE, ZA, IN and BR. Stale storefronts were AU, ES, IT, NO, NZ, JP and KR. Check SUMMARY for current coverage.

### Real output example

US prefill example from 15 October 2026; the dataset includes additional audit fields.

```json
{
  "verdict": "New Shopping app StylerOutlet- Gift Ideas Shop by MageComp, first released 15 Oct 2026 (US store), free, no website listed.",
  "appId": "6809700152",
  "originalReleaseDate": "2026-10-15T12:33:26.000Z",
  "appName": "StylerOutlet- Gift Ideas Shop",
  "publisherName": "MageComp",
  "publisherType": "unknown",
  "category": "Shopping",
  "price": 0,
  "currency": "USD",
  "priceCountry": "us",
  "publisherWebsite": null,
  "availableCountries": ["us"],
  "dateVerified": true
}
```

### Pricing and spending limits

You pay once per distinct verified app delivered, plus Apify's minimum start charge. No extra default dataset-row fee is added. Publisher groups, summaries, duplicates, old/future exclusions, missing app IDs and failed verifications have no app charge.

| Delivered apps | Base app charge | Bronze app charge |
| --- | --- | --- |
| 5 | $0.013 | $0.01235 |
| 25 | $0.065 | $0.06175 |
| 100 | $0.26 | $0.247 |
| 1,000 | $2.60 | $2.47 |

Add the $0.00005 minimum start charge to those examples. Silver is $0.00234 per app and Gold is $0.00208 per app. Base pricing is $0.0026; Bronze is $0.00247. The Actor has no additional outside API fees.

Set Apify's maximum charge to control spending. The Actor checks remaining capacity before enrichment and delivery, stops cleanly at the limit and records that decision in the summary. A low spending limit can reduce output below `maxApps`. An empty run incurs the platform start charge but no app charge.

### API and automation

Use the normal Apify API with your own token. Keep API tokens private.

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/moggedhq~app-store-new-apps/run-sync-get-dataset-items' \
  -H 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"countries":["us"],"since":"7 days","maxApps":5}'
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("moggedhq/app-store-new-apps").call(
    run_input={"countries": ["us"], "since": "7 days", "maxApps": 25}
)
rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('moggedhq/app-store-new-apps').call({
  countries: ['us'], since: '7 days', maxApps: 25
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Save a task, then connect its completed-run webhook to Make, Zapier, n8n or Sheets. For larger jobs, start asynchronously and fetch SUMMARY alongside the completed dataset.

### Use with AI agents (MCP)

Connect an agent to `https://mcp.apify.com` and ask it to find App Store new apps with first-release dates, publishers and supplied websites. For a direct run, name `moggedhq/app-store-new-apps` and specify countries, since and maxApps. Ask the agent to inspect `SUMMARY` as well as the dataset, preserve null websites and avoid presenting publisher labels as verified companies. Discovery needs no supplied IDs.

### Reliability and limits

Requests are sequential within each run, roughly three seconds apart. Retries use fresh proxy sessions and honour Retry-After. Datacenter proxies are tried first, with residential only as the final retry. Source responses are byte-bounded, and feed processing is capped independently of Apple's ignored limit parameter.

Verified rows, the original window, country state and candidate snapshots survive a reboot. Delivery and charging are serialized. Saved rows are reconciled with authoritative run event counts and durable acknowledged-charge receipts, so recovery does not rely only on a temporary charge key. If that evidence is ambiguous, the Actor stops rather than risking another charge. This protects delivery; it cannot make an unavailable or stale source complete.

### FAQ

**Does this find every newly released iPhone app?** No. It finds qualifying records in the queried public rolling feeds. Apps absent from those feeds are outside coverage.

**Can I backfill the last year?** A wider since date filters the current snapshot only. There is no complete historical backfill.

**Is a version update counted as a new launch?** No. Qualification uses original `releaseDate`, never the current version date or observation time.

**Are publishers verified businesses?** No. Publisher names may represent people or companies. Every publisherType remains unknown.

**Why is a website missing?** Apple did not supply a usable sellerUrl. No domain is inferred and no website crawling is performed.

**Why did a country return zero apps?** Its feed may be stale, your filters may have no matches, or no records may pass date verification. SUMMARY distinguishes these cases from failed source reads.

**Will the same app cost more across several countries?** One run deduplicates app IDs and charges once. Enable a stable watch to skip apps delivered on earlier sequential runs.

**Can I enrich known IDs?** Yes. Supply appIds; the first country determines lookup details. The same original-date window and filters still apply, so an old app can be excluded even when its metadata is available.

**Are grouped publishers extra?** No. The publisher dataset is a free grouping of the app rows already delivered.

**What happens with invalid input?** Inputs the Actor can parse become a free explanatory note and summary. Apify may reject schema-invalid requests before starting; no app is charged in either case.

# Actor input Schema

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

Tested storefront codes: us, gb, ca, au, de, fr, es, it, nl, se, no, dk, fi, ie, nz, za, in, jp, kr, br. Rolling feeds can be stale. App ID enrichment uses the first country.

## `since` (type: `string`):

Original release date cutoff, such as 7 days, yesterday or 2026-10-08. UTC dates. Feed coverage is rolling; wider dates do not retrieve complete history.

## `maxApps` (type: `integer`):

Maximum unique verified apps delivered. About $0.0026 per app plus the small Actor start charge. Duplicate storefront entries and failed verifications are free.

## `keywords` (type: `array`):

Optional OR substring filters over app name, publisher and category, for example fitness or finance. Filters the feed; not a complete App Store keyword search.

## `categories` (type: `array`):

Optional exact primary category names or numeric IDs, for example Productivity or 6007. OR within this list; combined with keywords.

## `excludeGames` (type: `boolean`):

Exclude apps whose Apple genre IDs include Games (6014).

## `publisherTypes` (type: `string`):

Publishers can be individuals or companies. Corporate verification is unavailable; every publisherType is unknown.

## `skipPreviouslyDelivered` (type: `boolean`):

Use with a stable watchId on sequential scheduled runs. Skip app IDs already delivered by this watch, even after version updates. Do not overlap runs.

## `watchId` (type: `string`):

Stable name for a daily watch, such as agency-us. Separate IDs keep separate delivery histories. Use letters, digits, underscores or hyphens.

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

Optional known app IDs for verification/enrichment instead of feed discovery. Uses the first country. Original date window and filters still apply. At most 1,000 IDs.

## Actor input object example

```json
{
  "countries": [
    "us"
  ],
  "since": "7 days",
  "maxApps": 5,
  "excludeGames": false,
  "publisherTypes": "any",
  "skipPreviouslyDelivered": false,
  "watchId": "default"
}
```

# Actor output Schema

## `apps` (type: `string`):

No description

## `publishers` (type: `string`):

No description

## `publisherDataset` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "countries": [
        "us"
    ],
    "since": "7 days",
    "maxApps": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("moggedhq/app-store-new-apps").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 = {
    "countries": ["us"],
    "since": "7 days",
    "maxApps": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("moggedhq/app-store-new-apps").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 '{
  "countries": [
    "us"
  ],
  "since": "7 days",
  "maxApps": 5
}' |
apify call moggedhq/app-store-new-apps --silent --output-dataset

```

## MCP server setup

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

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/638b0oTMT632GujCm/builds/6MBmMvyAkrWigN4PJ/openapi.json