# Google Play Developer Contacts · Emails & Legal Address (`corent1robert/google-play-developer-contacts`) Actor

Scrape public Google Play developer emails, websites and legal addresses. Search by keyword, package, Play URL or category. One unique Android publisher per row.

- **URL**: https://apify.com/corent1robert/google-play-developer-contacts.md
- **Developed by:** [Corentin Robert](https://apify.com/corent1robert) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 1,000 developer scrapeds

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/platform/actors/running/actors-in-store#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

### What does Google Play Developer Contacts do?

This Actor scrapes public [Google Play Store](https://play.google.com/store) listings and exports **one row per Android publisher** (`developerId`). Paste a **keyword**, **package name**, a Play **details URL**, and/or pick a **category**.

Each row is the contact file for that publisher:

- **Email + website** for outreach (when Google shows them)
- **Legal name, address, phones** when the developer published them
- **One sample app** (title, installs, rating) so you know who you are emailing

Empty fields mean Google did not publish that data — not a failed scrape. Two Zoho apps under the same publisher produce **one row**. That is intentional.

### Why scrape Google Play developer emails?

Sales, ASO, and SDK teams use Play listings to reach **Android app publishers**. Doing that by hand does not scale. Same unique-publisher file on Shopify: [Shopify App Store Developer Contacts](https://apify.com/corent1robert/shopify-app-developer-contacts).

- Build an outreach list of app makers in a niche (`invoice`, Dating, Business)
- Pull the public email and website Google already shows on the listing
- Keep a legal-entity file (address / phone) when the developer published one
- Cap volume with **Max developers** so a first run stays cheap

On Apify you can **schedule** runs, download **JSON / CSV / Excel**, and call the Actor from the **API** or integrations (Sheets, Make, n8n).

### What data can this Google Play scraper extract?

| Field | Description |
|---|---|
| `developerName`, `developerId`, `developerUrl` | Publisher identity and Play developer page |
| `developerEmail`, `developerWebsite` | Public listing contacts (Google Support URLs are dropped) |
| `legalName`, `legalEmail`, `legalAddress`, `legalPhone` | Legal entity fields when Google shows them |
| `appSupportPhone` | Public support phone when distinct from the legal phone |
| `appId`, `title` | Sample app used for this developer row |
| `installs`, `installsNumeric`, `score`, `ratingsCount` | Install band and rating of the sample app |
| `releasedAt`, `inAppPurchases` | Release date string and IAP flag when published |
| `country`, `sourceQuery`, `scrapedAt` | Run metadata |

Not extracted (and not invented): private emails, reviews, full-catalog dumps, genre slugs, ads flags, privacy-policy URLs, app counts, icons, long descriptions.

### How to scrape Google Play developer emails

1. Open this Actor in Apify Console.
2. **Step 1 — Mode:** leave **Search** (a niche) or switch to **Full catalog** (every Play category chart, paid). Catalog ignores keyword and category.
3. **Step 2 — Search** (Search mode only): keep `invoice`, or paste a package / Play URL. Optionally pick a category.
4. Leave **Country** on United States unless you need another Store.
5. Leave **Max developers** at 20 for a first run, then raise it. Full catalog: raise toward 20,000.
6. Click **Start**. Download the dataset as JSON, CSV, or Excel. Use the **Developers — Outreach** view for email columns.

In Search mode, query **or** category is required. Full catalog is paid Apify plans only. Google does **not** publish a developer sitemap — catalog is all category charts (top free / paid / grossing), then unique publishers.

See the **Input** tab for the visible options (proxy is optional and hidden).

### How much does it cost to scrape Google Play developers?

This Actor uses **pay-per-event** pricing. **Actor start is $0.00005** (Apify default — first 5 seconds of compute included). You only pay per **unique developer written to the dataset**. You are not charged per app listing. Paid Apify plans get a lower price per developer.

**Free plan:** a run stops at **20 developers** — enough to test. Keyword / category: paid plans can raise Max developers up to **2,000**. **Full catalog** (paid only) goes up to **20,000** unique publishers from category charts.

| Apify plan | Per developer | Per 1,000 |
|---|---|---|
| Free | **$0.005** | **$5.00** |
| Bronze | **$0.0045** | **$4.50** |
| Silver | **$0.004** | **$4.00** |
| Gold | **$0.0035** | **$3.50** |
| Platinum | **$0.003** | **$3.00** |
| Diamond | **$0.0025** | **$2.50** |

| Run | Approx. cost |
|---|---|
| Default / Free cap (20 developers) | **$0.10** |
| 100 developers (paid plans) | **$0.50** |
| 1,000 developers (paid plans) | **$5.00** |

Set **Max developers** and, on Apify, a **max total charge** so a run cannot exceed your budget. A row with an empty email still counts if **Require public email** is **No** — Google did not publish that field; the developer was still scraped.

Default memory is **512 MB** (HTTP only, no browser).

### Input

See the **Input** tab for full configuration options.

Visible Console fields:

| Field | Default | Notes |
|---|---|---|
| `coverage` | Search | **Search** = keyword/package and/or category. **Full catalog** = paid, all Play category charts. Catalog ignores query and category. Google does not publish a developer sitemap. |
| `query` | `invoice` | Search mode. Keyword, package (`com.example.app`), or Play details URL. Ignored in Full catalog. |
| `category` | None | Search mode, optional. Ignored in Full catalog. |
| `country` | `US` | Play Store country (`gl`) |
| `maxDevelopers` | 20 | Unique publishers (1–2000 Search, 1–20000 catalog). Free plan: 20 / run |
| `requireEmail` | `yes` | **Yes** (default) skips listings with no public email. **No** keeps them |

Proxy, delay, retries, and min-installs are hidden. Datacenter IPs usually work; use Residential only if Play serves a captcha (`/sorry/`).

Example:

```json
{
  "query": "invoice",
  "category": "",
  "country": "US",
  "maxDevelopers": 20,
  "requireEmail": "yes"
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "developerName": "Example Labs",
  "developerId": "1234567890123456789",
  "developerUrl": "https://play.google.com/store/apps/dev?id=1234567890123456789",
  "developerEmail": "support@example.com",
  "developerWebsite": "https://www.example.com",
  "legalName": "Example Labs LLC",
  "legalEmail": null,
  "legalAddress": "1 Example Street, Example City",
  "legalPhone": null,
  "appSupportPhone": null,
  "appId": "com.example.invoice",
  "title": "Example Invoice",
  "installs": "100,000+",
  "installsNumeric": 100000,
  "score": 4.4,
  "ratingsCount": 12000,
  "releasedAt": "Jan 12, 2018",
  "inAppPurchases": true,
  "country": "US",
  "sourceQuery": "invoice",
  "scrapedAt": "2026-08-14T08:00:00.000Z"
}
```

Console views: **Developers — Overview**, **Developers — Outreach** (email / website), **Developers — Publisher file** (legal name / address / phones).

### Tips

- A Google Play **category is not the full catalog**. Google publishes charts (about **200 apps** each) plus similar-app clusters. Raising **Max developers** walks those clusters; it does not unlock unpublished apps.
- Play search does not paginate reliably. Extra coverage comes from charts, similar apps, and extra search terms — not “page 2”.
- Do not mix countries in one run to inflate volume. `country` is a filter.
- Empty `developerEmail` / `legalAddress` means Google did not show them on that listing.

### Related Actors

Apify only auto-recommends Actors in the same category or with a similar name. These share the publisher-leads / ads-intel ICP:

| Actor | Use it when |
|---|---|
| [Shopify App Store Developer Contacts](https://apify.com/corent1robert/shopify-app-developer-contacts) | Same lead file — Shopify partners instead of Play publishers |
| [Amazon Manufacturer Emails](https://apify.com/corent1robert/amazon-manufacturer-emails) | EU GPSR manufacturer contacts on Amazon listings |
| [Google Ads Transparency Scraper](https://apify.com/corent1robert/google-ads-transparency-scraper) | Competitor Google Search / YouTube / Display creatives |
| [Facebook Ads Library Scraper](https://apify.com/corent1robert/facebook-ads-library-scraper) | Meta page ads, creatives and reach |
| [Facebook Page Contact Scraper](https://apify.com/corent1robert/facebook-page-contact-scraper) | Email, phone and website from a Facebook Page |
| [SW Website Rankings Scraper](https://apify.com/corent1robert/similarweb-scraper) | Rank the publisher site once you have the website |

### FAQ, disclaimers, and support

#### Is there a Google Play developer email API?

No official one. This Actor is a **Google Play developer email API alternative**: it reads the public listing Google already shows on the Store.

#### How do I find Android app developer emails?

Run a **keyword** (`invoice`) or a **category** (Business, Dating). Leave **Require public email** on **Yes**. Download the **Outreach** view as CSV.

#### Do you also scrape Shopify App Store developer emails?

Yes. [Shopify App Store Developer Contacts](https://apify.com/corent1robert/shopify-app-developer-contacts) is the same unique-publisher model on apps.shopify.com.

#### Can I scrape the whole Google Play Store?

**Paid plans:** set **Mode** to **Full catalog** and raise **Max developers**. That walks every Play **category chart** (top free / paid / grossing) and dedupes publishers. It is **not** a 3-million-app sitemap — Google does not publish one.

**Free plan:** no. Full catalog is rejected; search runs stop at 20 developers.

#### Does this scrape private emails?

No. It only reads fields the developer published on the Google Play listing.

#### Why do two apps become one row?

Rows are unique by `developerId`. Several apps from the same publisher share one contact file.

#### Why did I get fewer rows than Max developers?

Play ran out of publicly listed apps in that query/category, or **Require public email** is **Yes** and some listings have no email. On the **Free plan**, each run is also capped at **20 developers**. Check `OUTPUT` and `RUN_LOG`.

#### Why is an email or address empty?

Empty fields mean Google did not show them on that listing — not a failed scrape.

#### Do I pay an Actor-start fee?

Almost nothing: **$0.00005** per run (Apify default, first 5 seconds of compute included). The bill is the developers written to the dataset. Other Play scrapers often charge a start event plus **per app**.

#### Do I pay per app?

No. Two apps from the same publisher = **one** `developerId` = **one** charge. Pricing is per unique developer, not per listing.

#### Do I pay for rows with an empty email?

Only if **Require public email** is **No**. Pricing is **per developer scraped**, not per filled field.

#### Is a proxy required to scrape Google Play?

No. Enable Apify Proxy (Residential) only if you see `/sorry/` captchas.

Our Actors are ethical and do not extract private user data. They only extract what the developer has chosen to publish on the Google Play listing (public email, website, legal address). We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure, consult your lawyers.

Use the **Issues** tab for bugs and feature requests. Use the **API** tab to run the Actor programmatically. Custom needs: corentin@outreacher.fr

# Actor input Schema

## `coverage` (type: `string`):

**Search (default):** use Step 2 (keyword and/or category).

**Full catalog (paid):** walks every Play category chart (top free / paid / grossing). Not a 3-million-app dump — Google does not publish a publisher sitemap. Set Max developers to how many publishers you will pay for (up to 20,000). Free Apify plans cannot use Full catalog.

## `query` (type: `string`):

Examples: `invoice` · `com.zoho.invoice` · `https://play.google.com/store/apps/details?id=com.whatsapp`

Leave empty if you only pick a category. **Ignored** when Mode is Full catalog.

## `category` (type: `string`):

Optional, Search mode only. Leave **None** if you already typed a query. Charts seed the run. **Ignored** when Mode is Full catalog.

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

Play Store country. Charts and listings are country-specific — do not mix markets in one run.

## `maxDevelopers` (type: `integer`):

**Global** cap of unique `developerId` rows. Default **20** keeps first runs cheap. Search: up to **2,000**. Full catalog (paid): up to **20,000** (category charts, not a sitemap of all apps).

## `requireEmail` (type: `string`):

**Yes (default):** skip developers with no public email. **No:** also keep publishers without an email (legal name / address still scraped when Google publishes them).

## `minInstalls` (type: `integer`):

Keep developers whose sample app is at or above this install band (numeric lower bound, e.g. `10000` for 10K+). **0** = no filter. Hidden in Console.

## `proxyConfiguration` (type: `object`):

Optional. Datacenter is enough for most Play pages. Switch to Residential only if you hit a captcha (`/sorry/`). Hidden in Console.

## `minDelayMs` (type: `integer`):

Minimum pause between every HTTP request.

## `maxRequestRetries` (type: `integer`):

Retries on block / 5xx, rotating the proxy session when a proxy is configured.

## Actor input object example

```json
{
  "coverage": "search",
  "query": "invoice",
  "category": "",
  "country": "US",
  "maxDevelopers": 20,
  "requireEmail": "yes",
  "minInstalls": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "minDelayMs": 400,
  "maxRequestRetries": 5
}
```

# Actor output Schema

## `overview` (type: `string`):

Name, email, website, sample app

## `outreach` (type: `string`):

Email and website for a first outreach pass

## `publisher` (type: `string`):

Legal name, address, phones

## `dataset` (type: `string`):

All developer rows

## `output` (type: `string`):

Developers scraped, apps fetched, filters

## `runLog` (type: `string`):

Live progress

# 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 = {
    "query": "invoice"
};

// Run the Actor and wait for it to finish
const run = await client.actor("corent1robert/google-play-developer-contacts").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 = { "query": "invoice" }

# Run the Actor and wait for it to finish
run = client.actor("corent1robert/google-play-developer-contacts").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": "invoice"
}' |
apify call corent1robert/google-play-developer-contacts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,corent1robert/google-play-developer-contacts"
        }
    }
}

```

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/sllre196hyQaUFneV/builds/UNEQQgmnpdMaPzGfW/openapi.json