# Shopify App Store Developer Contacts · Emails & Address (`corent1robert/shopify-app-developer-contacts`) Actor

Scrape Shopify App Store developer leads — public emails, websites and legal addresses. Keyword, URL, category, or full unique-partner catalog (paid). One unique partner per row, not per app.

- **URL**: https://apify.com/corent1robert/shopify-app-developer-contacts.md
- **Developed by:** [Corentin Robert](https://apify.com/corent1robert) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **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 Shopify App Store Developer Contacts do?

This Actor is a **Shopify App Store developer email scraper** (a public **developer-leads API alternative**). It reads [apps.shopify.com](https://apps.shopify.com) and exports **one row per unique partner** — not one row per app.

Paste a **keyword**, an **app handle**, a listing **URL**, a **partner URL**, and/or pick a **category**. Each row is the outreach file:

- **Support email + website** when Shopify publishes them on the listing
- **Legal address** when the partner listed one
- **Portfolio** (`appCount` / `appHandles`) from the partner page, plus one sample app (title, rating)

Empty fields mean Shopify did not publish that data — not a failed scrape. Two Klaviyo apps under the same partner produce **one lead**. That is the product.

### Why scrape Shopify App Store developer emails?

Agencies, SaaS tools, and Shopify ecosystem vendors use the App Store to reach **app publishers**. Doing that by hand does not scale. Same unique-publisher file on Android: [Google Play Developer Contacts](https://apify.com/corent1robert/google-play-developer-contacts).

- Build an outreach list of partners in a niche (`invoice`, Email marketing, Store design)
- Pull the public support email Shopify already shows on the listing
- Keep an address file when the partner 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 Shopify App Store scraper extract?

| Field | Description |
|---|---|
| `developerName`, `developerId`, `developerUrl` | Partner identity and `/partners/{slug}` page |
| `developerEmail`, `developerWebsite` | Public listing contacts (Website may be a docs portal) |
| `legalAddress` | Public address when Shopify shows it |
| `appHandle`, `title` | Sample app used for this partner row |
| `score`, `ratingsCount`, `releasedAt` | Rating and launch date of the sample app |
| `appCount`, `appHandles` | Portfolio on the first partner page |
| `sourceQuery`, `scrapedAt` | Run metadata |

Not extracted (and not invented): private emails, merchant reviews, pricing plans, guessed emails from the partner’s marketing site. Full catalog is unique **partners**, not 25k app rows.

### How to scrape Shopify App Store developer emails

1. Open this Actor in Apify Console.
2. **Step 1 — Mode:** leave **Search** (a niche) or switch to **Full catalog** (every unique partner, paid). Pick one — catalog ignores keyword and category.
3. **Step 2 — Search** (Search mode only): keep `invoice`, or paste a handle / listing URL / partner URL. Optionally pick a category. Query and category together are a union, then deduped by partner.
4. Leave **Max developers** at 20 for a first run, then raise it (related-app coverage starts when the seed pool is too small). Full catalog: raise it toward 20,000 for the whole file.
5. 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.

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

### How much does it cost to scrape Shopify App Store 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 partner 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 partners.

| 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** |
| Full catalog (~16k unique partners, paid) | **~$80** on Free-tier PPE ($0.005); less on Gold/Diamond |

**Full catalog** walks the public English **partner sitemap** (about **16,000 unique publishers**, not 25k app listings). Paid Apify plans only. Leave **Max developers** at 20 to test; set it to **20,000** for the whole unique-partner file. Expect a few hours (HTTP + delay). Set a **max total charge** so the run cannot exceed your budget.

Most Shopify App Store scrapers on Apify charge **per app listing** ($2–$5 / 1,000 apps) or add a **$0.10 start fee**. Contact-focused Actors often charge **$4 / 1,000 apps** (duplicates included) or **$20–$50 / 1,000** for a “qualified” email. Here you pay **$5 / 1,000 unique partners** on the Free plan — Klaviyo’s two apps are one charge, not two.

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** — Shopify did not publish that field; the partner 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/URL and/or category. **Full catalog** = paid, English partner sitemap (~16k unique partners). Catalog ignores query and category. |
| `query` | `invoice` | Search mode. Keyword, hyphenated app handle, listing URL, or `/partners/{slug}` URL. Ignored in Full catalog. |
| `category` | None | Search mode, optional. Ignored in Full catalog. |
| `maxDevelopers` | 20 | Unique partners (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, and retries are hidden. Direct HTTP usually works.

Example:

```json
{
  "query": "invoice",
  "category": "",
  "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": "example-labs",
  "developerUrl": "https://apps.shopify.com/partners/example-labs",
  "developerEmail": "support@example.com",
  "developerWebsite": "https://www.example.com",
  "legalAddress": "1 Example Street, Example City, US",
  "appHandle": "example-invoice",
  "title": "Example Invoice",
  "score": 4.7,
  "ratingsCount": 120,
  "releasedAt": "January 12, 2018",
  "appCount": 2,
  "appHandles": ["example-invoice", "example-reviews"],
  "sourceQuery": "invoice",
  "scrapedAt": "2026-08-14T08:00:00.000Z"
}
```

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

### Tips

- A Shopify **category is not the full catalog**. For every unique partner, set **Mode** to **Full catalog** (paid) and raise **Max developers**. Search mode walks keyword / category + related apps only.
- Search paginates (Turbo-Frame). Related apps on each listing then fill the rest of the cap.
- Locale is locked to **English**. Do not mix locales in one run to inflate volume.
- Empty `developerEmail` / `legalAddress` means Shopify did not show them on that listing.
- `appCount` is what the **first partner page** lists — not a guaranteed full catalog for huge portfolios.

### Related Actors

Apify only auto-recommends Actors in the same category or with a similar name. These are the ones that share this ICP (publisher / marketplace leads, then ads intel and website enrichment):

| Actor | Use it when |
|---|---|
| [Google Play Developer Contacts](https://apify.com/corent1robert/google-play-developer-contacts) | Same lead file — Android publishers instead of Shopify partners |
| [Shopify Product Scraper](https://apify.com/corent1robert/shopify-products-scraper) | A merchant store catalog — not App Store partners |
| [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 partner site once you have `developerWebsite` |

### FAQ, disclaimers, and support

#### Is there a Shopify App Store developer email API?

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

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

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

#### Do you also scrape Google Play developer emails?

Yes. [Google Play Developer Contacts](https://apify.com/corent1robert/google-play-developer-contacts) is the same unique-publisher model on the Play Store.

#### How is this different from a Shopify App Store scraper?

Catalog scrapers dump **one row per app** (pricing, reviews, ASO). This Actor dumps **Shopify App Store developer leads**: unique partners with public email / website / address. Same publisher, one row.

#### Can I scrape the whole Shopify App Store?

**Paid plans:** set **Mode** to **Full catalog** and **Max developers** to 20,000. That walks the English **partner** sitemap (~16k unique publishers). It is not 25k app rows — two apps from the same partner stay one lead.

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

#### Does this scrape private emails?

No. It only reads fields the partner published on the Shopify App Store listing. It does not crawl the partner’s marketing site to guess extra inboxes.

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

Rows are unique by partner slug. Several apps from the same publisher share one contact file.

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

The App Store 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 Shopify 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 partners written to the dataset. Other App Store scrapers often charge a start event plus **per app**.

#### Do I pay per app?

No. Two apps from the same partner = **one** slug = **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 the Shopify App Store?

No. Enable Apify Proxy only if you get blocked.

Our Actors are ethical and do not extract private user data. They only extract what the partner has chosen to publish on the Shopify App Store 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

*Keywords: Shopify App Store scraper, Shopify App Store leads, Shopify app developer email, Shopify partner contacts, Shopify App Store developer leads API.*

# Actor input Schema

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

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

**Full catalog (paid):** walks ~16k unique publishers. Leave Step 2 empty — it is ignored. Set Max developers to how many partners you will pay for (up to 20,000, typically $40–80). Free Apify plans cannot use Full catalog.

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

Examples: `invoice` · `klaviyo-email-marketing` · `https://apps.shopify.com/klaviyo-email-marketing` · `https://apps.shopify.com/partners/klaviyo`

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. **Ignored** when Mode is Full catalog.

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

**Global** cap of unique partner rows. Default **20** keeps first runs cheap. Keyword mode: up to **2,000**. Full catalog (paid): up to **20,000** (~16k partners on the English sitemap).

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

**Yes (default):** skip partners with no public email. **No:** also keep publishers without an email (website / address still scraped when Shopify publishes them).

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

Optional. Direct HTTP is enough for most App Store pages. Enable Apify Proxy only if you get blocked. 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": "",
  "maxDevelopers": 20,
  "requireEmail": "yes",
  "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`):

Address and partner portfolio

## `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/shopify-app-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/shopify-app-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/shopify-app-developer-contacts --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,corent1robert/shopify-app-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/XgQvhy1WqmudbXtTy/builds/PdzJ1pWM6qX22oeow/openapi.json