# Salesforce AppExchange · Partner Emails by Category (`corent1robert/salesforce-appexchange-vendor-contacts`) Actor

Export unique AppExchange ISVs with listing emails, HQ, website and app count. One partner per row. Public directory — no Salesforce login.

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

## Pricing

from $1.40 / 1,000 unique appexchange publishers

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?

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

## Salesforce AppExchange · Partner Emails by Category

Export **unique Salesforce AppExchange publishers (ISVs)** with a **public email, phone, HQ and website** — **one vendor per row**, not one row per listing.

**No login. No Salesforce API key. No partner account.**

### Who is this for?

| You are… | Typical goal | Suggested setup |
|---|---|---|
| Partnership / alliances at a Salesforce ISV | Co-sell with apps already on AppExchange | Category **Sales**, cap 50–200, **Outreach** view |
| Outbound / SDR on the Salesforce ecosystem | A first-email list, not 5k listing rows | Keep **Find public emails** On, skip Salesforce-owned |
| AppExchange / SI agency | Publishers who already invest in a listing | **Paid listings only** + emails On |
| Marketplace researcher | Coverage of a niche | Full catalog (paid); emails Off if you only need domains |

**What you get by default:** unique publisher, **listing email when the ISV published one**, phone, HQ, website, categories, paid flag, sample listing. Salesforce and Salesforce Labs publishers are skipped unless you turn that filter off.

**When to keep Find public emails On:** most commercial ISVs already show `sales@` / `partners@` on the listing. The company site is opened only when that inbox **or** the phone is missing — so you still fill Adobe-style phone-only rows without guessing addresses.

**Typical fill (public Sales slice, 20 publishers, Aug 2026):** **19 / 20** rows had a listing inbox (e.g. `sales@nintex.com`, `partners@pandadoc.com`, `sales@zoominfo.com`, `partners@conga.com`, `sales@sdocs.com`, `salesforce@gong.io`). **18 / 20** had a phone. Four sites were opened only because inbox or phone was missing; none refused.

### How to use

1. Open this Actor in Apify Console.
2. **Step 1 — Mode:** leave **Search** (a niche) or switch to **Full catalog** (every unique publisher, paid). Catalog ignores keyword and category.
3. **Step 2 — Search** (Search mode only): leave category **Sales**, or paste a listing URL from AppExchange. Optionally type a keyword (`nintex`, `cpq`).
4. Keep **Find public emails** **On**. Leave **Max vendors** at 20 for a first run, then raise it.
5. Click **Start**. Download JSON / CSV / Excel. **Outreach** = first email. **Overview** = email + HQ + price floor. **Qualify** = industries, clouds, Lightning / FedRAMP.

In Search mode, query **or** category is required. Full catalog is a paid-scale job (thousands of unique publishers).

### Ready-made Console tasks

| Example | Best for |
|---|---|
| [Find AppExchange Sales ISVs with emails](https://console.apify.com/actors/tasks/88XeTn0EFzYsYTrCa) | Flagship Sales vertical, listing inboxes |
| [Export AppExchange marketing app vendors](https://console.apify.com/actors/tasks/gd0YeONZMxW3RvObA) | Marketing category, Overview view |
| [Refresh AppExchange publisher from a listing URL](https://console.apify.com/actors/tasks/BcAO5BMpy7nJTqLcH) | Paste one listing URL |
| [Paid AppExchange publishers for outreach](https://console.apify.com/actors/tasks/pdsUS7xdtYwp6hyUG) | Paid listings only |

When this Actor is Store-public, the same four tasks can land on the **Examples** tab.

### What does AppExchange Partner Emails do?

This Actor builds an **outreach / partnership file** from the public [Salesforce AppExchange](https://appexchange.salesforce.com/). You are not here to dump 5,000 app cards. You want the companies that already listed a product: **who to email**, **which site they run**, **where they sit**.

Unlike Zapier, many ISVs **do publish** a sales or support inbox on the listing. Each row is that file:

- **Listing inbox** (`sales@`, `partners@`, support, publisher email) when Salesforce shows it
- **Listing phone** and **HQ** when they filled them
- **Website, domain, categories, paid flag, listing URL, app portfolio** in this run
- If the listing inbox **or** phone is empty and **Find public emails** is On: a **public inbox / phone from their company site**

Empty `developerEmail` means the ISV did not publish an inbox on the listing or their site (form / chat only) — not a guessed `john@company.com`. Two listings under the same website stay **one lead**.

### What data can this AppExchange scraper extract?

| Field | Why it matters for ICP |
|---|---|
| `developerEmail`, `emails`, `emailSource` | Listing inbox (`appexchange-listing`) or company site (`publisher-website`) |
| `phone`, `phones` | Listing phone and/or public `tel:` |
| `contactStatus` | Filter the export: `email` / `email_and_phone` vs `no_contact` vs `crawl_failed` |
| `publisherName`, `website`, `websiteDomain`, `hqLocation`, `country` | Company + clean host + HQ for CRM match |
| `categories`, `categoriesLabel`, `isPaid`, `rating`, `reviewCount` | Niche + commercial signal (`categoriesLabel` is spreadsheet-friendly) |
| `startingPrice`, `pricingLabel`, `hasTrial`, `discountsOffered` | Budget floor from the listing (e.g. USD 30/user/month) — not a full price book |
| `industriesLabel`, `compatibleCloudsLabel`, `editionsLabel`, `languagesLabel` | ICP fit: FSI vs manufacturing, Sales Cloud, Enterprise edition, FR/EN |
| `lightningReady`, `isFedrampCertified`, `isMobileReady` | Enterprise / public-sector signal |
| `listedOn`, `latestRelease`, `tagline`, `shortDescription` | Tenure + freshness + one-line pitch |
| `appCount`, `listingIds`, `appNames`, `sampleAppName`, `listingUrl` | Portfolio in this run + sample listing |
| `websiteFetchUrl`, `scrapedAt` | Which page produced a site inbox + run time |

Not extracted (and not invented): Salesforce org login emails, guessed `firstname@domain` patterns, private partner-dashboard contacts, **review text**, screenshot carousels, package object counts, security-review legalese, full pricing packages.

Two listings that share the same company website stay **one lead**.

### How much does it cost to scrape AppExchange publishers?

This Actor uses **pay-per-event** pricing. **Actor start is $0.00005** (Apify default). You pay per **unique publisher written to the dataset**. When **Find public emails** is On **and** the listing inbox or phone is missing, you also pay one **website crawl** per publisher whose site is fetched. You are not charged per AppExchange listing card. Paid Apify plans get a lower price per event.

**Free plan:** a run is meant for a **20-vendor try**. Keyword / category: paid plans can raise Max vendors up to **2,000**. **Full catalog** (paid) goes up to **5,000** unique publishers (public apps are ~5,500 listings; several listings can share one ISV).

| | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Per unique publisher | $0.002 | $0.0018 | $0.0016 | $0.0014 | $0.0012 | $0.001 |
| Per website crawl (inbox or phone missing) | $0.0015 | $0.0014 | $0.0013 | $0.0012 | $0.0011 | $0.001 |
| 20 vendors, listing contacts only | **$0.04** | $0.04 | $0.03 | $0.03 | $0.02 | $0.02 |
| 20 vendors + 5 site fetches | **$0.05** | $0.04 | $0.04 | $0.03 | $0.03 | $0.03 |
| 1,000 vendors, listing contacts | **$2.00** | $1.80 | $1.60 | $1.40 | $1.20 | $1.00 |
| 1,000 vendors + 200 site fetches | **$2.30** | $2.08 | $1.86 | $1.64 | $1.42 | $1.20 |

Totals include the $0.00005 start. Two apps from the same publisher are **one charge**.

Set **Max vendors** and, on Apify, a **max total charge** so a run cannot exceed your budget. A row with an empty email still counts — the publisher was scraped; they did not publish an inbox.

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

### Is it legal to scrape Salesforce AppExchange?

This Actor only accesses data that Salesforce makes **publicly available** on [appexchange.salesforce.com](https://appexchange.salesforce.com/) (name, listing contacts, website, HQ, categories) and, when **Find public emails** is On, data the **publisher chose to show** on their own public website. As with any data containing personal information, ensure your use complies with GDPR and relevant regulations. Do not scrape personal data unless you have a legitimate reason to do so.

### 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 walk of public apps. Catalog ignores query and category. |
| `query` | empty | Search mode. Keyword or listing page URL. Ignored in Full catalog. |
| `category` | Sales | Search mode, optional if you typed a query. Ignored in Full catalog. |
| `maxVendors` | 20 | Unique publishers (**0** = no extra cap besides your plan). Free try: 20 |
| Find public emails (`websiteEnrichment`) | **On** | Listing contacts first; company site if inbox or phone is missing |
| `skipSalesforcePublishers` | Yes | Drops Salesforce / Labs publishers |
| `paidOnly` | No | Keep paid listings only |

**API-only:** `verboseLogs` (boolean). Direct HTTP is enough for the public directory; pass `proxyConfiguration` in JSON only if you need Apify Proxy.

**Search — Sales with emails (default Try):**

```json
{
  "coverage": "search",
  "query": "",
  "category": "sales",
  "maxVendors": 20,
  "websiteEnrichment": "yes",
  "skipSalesforcePublishers": "yes",
  "paidOnly": "no"
}
```

**One listing URL:**

```json
{
  "coverage": "search",
  "query": "https://appexchange.salesforce.com/appxListingDetail?listingId=a0N300000016Zn3EAE",
  "category": "",
  "maxVendors": 1,
  "websiteEnrichment": "yes"
}
```

**Full catalog (paid, listing contacts only):**

```json
{
  "coverage": "catalog",
  "maxVendors": 500,
  "websiteEnrichment": "no",
  "skipSalesforcePublishers": "yes"
}
```

### Output

You can download the dataset in JSON, HTML, CSV, or Excel.

```json
{
  "publisherName": "Docusign, Inc",
  "website": "https://www.docusign.com",
  "websiteDomain": "docusign.com",
  "developerEmail": "sales@docusign.com",
  "phone": "18777202040",
  "emailSource": "appexchange-listing",
  "contactStatus": "email_and_phone",
  "startingPrice": 30,
  "pricingLabel": "USD 30/user/monthly",
  "hasTrial": true,
  "industriesLabel": "Financial Services · Manufacturing",
  "compatibleCloudsLabel": "Sales Cloud · Revenue Cloud · Experience Cloud",
  "lightningReady": true,
  "isFedrampCertified": true,
  "listedOn": "2010-03-07",
  "tagline": "Close deals faster in Salesforce with Docusign eSignature for Salesforce",
  "sampleAppName": "Docusign eSignature for Salesforce: The trusted eSignature solution",
  "listingUrl": "https://appexchange.salesforce.com/appxListingDetail?listingId=a0N30000001taX4EAI"
}
```

Console views: **Outreach** (first email), **Overview** (email + HQ + price floor), **Qualify** (industries, clouds, Lightning / FedRAMP).

`contactStatus`: `email` · `phone` · `email_and_phone` · `no_contact` (site loaded, nothing public) · `crawl_failed` (site refused) · `website_only` (Find public emails Off).

### Tips

- Filter CSV on `contactStatus` = `email` or `email_and_phone` before you import a sequencer.
- `appCount` is how many of that vendor’s listings appeared **in this run** — not a guaranteed full AppExchange portfolio.
- Empty email + `phone` (Adobe-style) is still a usable row. Empty email + `no_contact` means form-only — keep the website.
- A category is **not** the full catalog. For every unique publisher, set **Mode** to **Full catalog**.

### Also available

**[Zapier Apps · Publisher Emails by Category](https://apify.com/corent1robert/zapier-app-directory-developer-contacts)** — unique Zapier publishers with public emails from their websites.\
**[HubSpot Marketplace App Partners](https://apify.com/corent1robert/hubspot-marketplace-app-partners)** — unique HubSpot app vendors with named outreach contacts.\
**[Slack Marketplace · Unique Developer Emails](https://apify.com/corent1robert/slack-app-directory-developer-contacts)** — unique Slack app publishers with public listing emails.

### How to run via API

```bash
curl "https://api.apify.com/v2/acts/corent1robert~salesforce-appexchange-vendor-contacts/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"coverage":"search","category":"sales","maxVendors":20,"websiteEnrichment":"yes"}'
```

### Local development

```bash
cd salesforce-appexchange-vendor-contacts
npm install
npm test
apify run --purge --input-file=./input.json
```

Default Try input is Search **Sales**, 20 vendors, **Find public emails On**. That writes `storage/datasets/default/`. Do not use `npm start` for a simulated Actor run.

Engine tests (listing URL / domain / email pick):

```bash
npm test
```

### Performance

HTTP only, 512 MB default, 4h timeout. A **20-vendor Sales run** typically finishes in **under a minute** when most inboxes are on the listing. Full catalog (~5,500 apps → unique publishers) is a longer paid job — budget time and **website crawl** events if emails stay On.

### FAQ, disclaimers, and support

#### Does Salesforce list publisher emails?

Often yes, on the listing (sales / partners / support / publisher). This Actor prefers that inbox. The company website is fetched only when that inbox **or** the phone is missing.

#### How do I find AppExchange ISV emails?

Leave **Find public emails** On. Pick **Sales** (or Marketing) or paste a listing URL. Download the **Outreach** view and keep rows where `developerEmail` is filled.

#### Why is the email empty?

Either the ISV only has a form (`no_contact`), the site refused the visit (`crawl_failed`), Find public emails is Off (`website_only`), or they published a phone only (`phone`). Check `contactStatus`.

#### Do you invent emails from the company name?

No. Only addresses published on the listing or the vendor site.

#### How is this different from an AppExchange apps scraper?

Listing scrapers dump **one row per app** (descriptions, screenshots). This Actor dumps a **partnership file**: unique vendors with a public inbox when they publish one. Same publisher, one row.

#### Can I scrape the whole AppExchange?

**Paid plans:** set **Mode** to **Full catalog** and raise **Max vendors**. Public apps collapse to unique websites. With emails On, expect crawl events only when listing contacts are incomplete.

**Free plan:** keep a 20-vendor try.

#### Do I pay per listing?

No. Two apps from the same website = **one** publisher = **one** `partner-row`. Emails On adds **one** `website-crawl` when the site is fetched.

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

Yes if the publisher was written to the dataset. Pricing is **per vendor scraped**, not per filled inbox. Filter `contactStatus` after the run.

#### Is a proxy required?

No. Enable Apify Proxy in JSON input only if you get blocked.

#### Do I need a Salesforce API key?

No. Public directory + public publisher websites only.

Our Actors are ethical and do not extract private user data. They only extract what Salesforce shows on the public AppExchange and what the publisher chose to publish on their own website. 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: Salesforce AppExchange scraper, AppExchange ISV email, Salesforce partner leads, AppExchange publisher contacts, Salesforce app vendor emails.*

# Actor input Schema

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

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

**Full catalog (paid):** walks public AppExchange apps into unique publishers. Leave Step 2 empty — it is ignored. Free Apify plans cannot use Full catalog.

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

Examples: `nintex` · paste an AppExchange listing page URL.

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.

## `maxVendors` (type: `integer`):

**Global** cap of unique publisher rows (one company, many listings). Default **20**. Keyword/category: up to **2,000**. Full catalog (paid): up to **5,000**. **0** = no extra cap besides your paid plan.

## `skipSalesforcePublishers` (type: `string`):

**Yes (default):** keep independent ISVs only. **No:** include Salesforce and Salesforce Labs publishers.

## `paidOnly` (type: `string`):

**No (default):** free and paid apps. **Yes:** keep paid AppExchange listings only (stronger commercial signal).

## `websiteEnrichment` (type: `string`):

**On (recommended):** use the listing inbox and phone when the ISV published them. If either is missing, open the company website for a public email / phone.

**Off:** listing fields only — cheaper if you already enrich domains in Clay.

## `websiteEmailMaxPages` (type: `integer`):

Homepage plus same-origin contact/legal pages when Site enrichment is On.

## `verboseLogs` (type: `boolean`):

Add debug lines to the run log.

## Actor input object example

```json
{
  "coverage": "search",
  "category": "sales",
  "maxVendors": 20,
  "skipSalesforcePublishers": "yes",
  "paidOnly": "no",
  "websiteEnrichment": "yes",
  "websiteEmailMaxPages": 5,
  "verboseLogs": false
}
```

# Actor output Schema

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

Email, phone, website, HQ, categories

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

Inbox and website for a first partnership email

## `qualify` (type: `string`):

Price floor, industries, clouds, Lightning / FedRAMP

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

All publisher rows

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

Publishers scraped and 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": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("corent1robert/salesforce-appexchange-vendor-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": "" }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,corent1robert/salesforce-appexchange-vendor-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/cmFOnnGAqF9186j0a/builds/kfw2t5UgXU4C92dv6/openapi.json