# Salesforce AppExchange Email Scraper (`leads-scraper/salesforce-appexchange-email-scraper`) Actor

Salesforce AppExchange Email Scraper SD - Salesforce AppExchange Email Scraper is a lead generation tool that extracts leads with public contact emails, account names and profile URLs from Salesforce AppExchange results by keyword, location and email domain - Salesforce AppExchange email extractor.

- **URL**: https://apify.com/leads-scraper/salesforce-appexchange-email-scraper.md
- **Developed by:** [Leads Scraper](https://apify.com/leads-scraper) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### Salesforce AppExchange Email Scraper

The **Salesforce AppExchange Email Scraper** builds a deduplicated contact list of AppExchange ISV partners, consulting partners and system integrators from Google's public index of `appexchange.salesforce.com`.
It is designed for partner recruitment, integration partnerships, agency sourcing and competitive research inside the Salesforce ecosystem.
No login, no Salesforce API, no browser automation — publicly indexed search results only.

One thing to know up front, because it shapes every dataset you will get: **AppExchange listing URLs use opaque query-string ids, so most rows carry the partner email and listing name without a profile URL.**
That is not a defect in the Salesforce AppExchange Email Scraper — it is how AppExchange addresses its own pages, with `appxListingDetail?listingId=a0N3A0000...` rather than a readable slug.
You still get the partner name, the listing title, the description snippet and the email; you often do not get a clickable profile link.

In our measured test runs the Salesforce AppExchange Email Scraper attached an account identity to **8 of 10** sampled rows.
Identity here usually means a partner or listing name rather than a handle, for exactly the reason above.
Yield varies with keywords, domain filter and country.

#### Who the Salesforce AppExchange Email Scraper is for

Partner and alliance teams recruiting ISVs, SaaS vendors looking for implementation partners, agencies sourcing subcontractors, and analysts mapping the Salesforce partner landscape.
AppExchange listings are commercial storefronts, so the addresses on them exist precisely to receive partnership and support enquiries — a salesforce appexchange partner email is a business contact by design.
Enterprise teams commonly run this alongside the [HubSpot Marketplace Email Scraper](https://apify.com/leads-scraper/hubspot-marketplace-email-scraper) to cover both major CRM ecosystems.

### What the Salesforce AppExchange Email Scraper actually does

The Salesforce AppExchange Email Scraper does **not** sign into AppExchange, call any Salesforce API, or open the marketplace in a browser.
It builds Google queries with the `site:appexchange.salesforce.com` operator, fetches result pages through the Apify **GOOGLE_SERP** proxy with `aiohttp`, and parses each result block.
There is no headless browser, no JavaScript rendering, no authentication and no cookies.

Result blocks are located structurally — find the `<h3>` title, then take the smallest surrounding block — rather than depending on Google's CSS class names.
A domain-filtered regex extracts addresses from that block text, results are deduplicated globally, and every lead is pushed to the Apify dataset as soon as it is found.
A whole-page fallback parser keeps the run producing emails if Google's markup shifts.

That makes the Salesforce AppExchange Email Scraper a **publicly indexed contact discovery** tool for the Salesforce partner ecosystem.
It reads what partners chose to publish on their listings. Nothing private, nothing gated.

### Key features of the Salesforce AppExchange Email Scraper

| Feature | What it means for your Salesforce partner contact list |
|---|---|
| `site:` targeting | Queries are scoped to `appexchange.salesforce.com`, so results stay inside the marketplace |
| Query expansion | Base, quoted and `intitle:` phrasings plus one variant per query modifier, per keyword x domain pair |
| Partner-tuned modifiers | Defaults are `email`, `contact`, `support`, `developer`, `publisher` — the words partner listings use |
| Domain filtering | Only addresses ending in your `customDomains` values are kept; leading `@` optional |
| Global deduplication | One row per address per run, regardless of how many listings mention it |
| Obfuscation handling | Reads `name [at] domain [dot] com`, `name (at) domain`, `name @ domain.com`, `domain .com`, zero-width characters and the full-width `＠` |
| Junk filter | Rejects placeholders such as `email@`, `yourname@`, `test@`, `xxx@` and single-character locals |
| Boundary-correct matching | `@gmail.com` cannot match inside `@gmail.company` or `@gmail.com.br` |
| Soft-wrap repair | Drops a hit that is only the tail of another email in the same result block |
| Async concurrency | An `asyncio` worker pool runs queries in parallel with a shared stop signal on `maxEmails` |
| Retries and backoff | Up to 3 attempts per page, exponential backoff, a fresh proxy session per request |
| Block detection | CAPTCHA, "unusual traffic" and consent pages are detected and retried, not counted as empty |
| Failed-query requeue | Blocked or failed queries get one more attempt at the end of the run |
| Resumable state | Key-value store state keyed by an input hash, saved on `PERSIST_STATE`, `MIGRATING` and `ABORTING` |
| Fallback parser | Whole-page extraction when Google's layout changes |
| Run summary | Logs pages fetched, blocked pages, retries and emails per page |

### How the Salesforce AppExchange Email Scraper works, step by step

1. Reads input: keywords, location, email domains and run limits.
2. Builds Google queries such as `site:appexchange.salesforce.com salesforce partner consulting "@gmail.com"`.
3. Fetches Google result pages asynchronously through the Apify GOOGLE_SERP proxy.
4. Locates each organic result block structurally and reads its visible text.
5. Applies the domain filter, junk filter and soft-wrap repair to every candidate address.
6. Deduplicates globally and streams each new lead into the dataset immediately.

Base queries run before expanded ones, so the highest-signal Salesforce AppExchange Email Scraper rows land first.
If you cut a run short at 100 emails, those come from the strongest phrasings, not an arbitrary corner of the expansion set.
The shared stop signal halts all workers the moment `maxEmails` is hit.

### Input reference for the Salesforce AppExchange Email Scraper

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array (required) | `["salesforce partner", "consulting"]` | Search terms describing the partners you want |
| `location` | string | `""` | Optional location phrase added to every query |
| `customDomains` | array | `["@gmail.com","@yahoo.com"]` | Only emails on these domains are kept; `@` optional |
| `maxEmails` | integer 1-10000 | `20` | Stop after this many unique emails |
| `countryCode` | string | `""` | Two-letter country for the search proxy (US, GB, DE...) |
| `expandQueries` | boolean | `true` | Search each keyword x domain in several phrasings |
| `queryModifiers` | array | `["email","contact","support","developer","publisher"]` | Extra words combined with each keyword when expansion is on |
| `maxPagesPerQuery` | integer 1-50 | `30` | Page cap per query |
| `maxConcurrency` | integer 1-20 | `5` | Parallel queries |

#### Example input for the Salesforce AppExchange Email Scraper

```json
{
  "keywords": [
    "salesforce consulting partner",
    "appexchange isv app",
    "salesforce implementation partner"
  ],
  "location": "United Kingdom",
  "customDomains": ["@gmail.com", "@outlook.com"],
  "maxEmails": 400,
  "countryCode": "GB",
  "expandQueries": true,
  "queryModifiers": ["email", "contact", "support", "developer", "publisher"],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

Use the vocabulary AppExchange listings use about themselves — "consulting partner", "managed package", "implementation partner", a specific cloud such as "Service Cloud".
The Salesforce AppExchange Email Scraper matches indexed listing text, not a partner tier taxonomy.

### Output reference: what the Salesforce AppExchange Email Scraper returns

Every dataset item carries all 14 fields, even when a value is empty or `null`.

| Field | Meaning |
|---|---|
| `network` | Platform name |
| `keyword` | The keyword that produced the lead |
| `query` | The exact Google query used |
| `title` | Raw result title |
| `accountName` | Account label Google prints |
| `fullName` | Display name parsed from a profile-style title; empty for non-profile results |
| `username` | URL-safe handle when the platform exposes one; otherwise `null` |
| `profileUrl` | Canonical account URL when a handle is known; otherwise empty |
| `url` | Direct platform link when exposed, else the profile URL |
| `description` | Listing snippet, cleaned of labels and counters |
| `email` | Lower-cased email address |
| `emailDomain` | The matched domain (e.g. `@gmail.com`) |
| `possiblyTruncated` | `true` when Google's snippet ellipsis touched the email |
| `foundAt` | ISO 8601 UTC timestamp |

#### Example output from the Salesforce AppExchange Email Scraper

```json
[
  {
    "network": "Salesforce AppExchange",
    "keyword": "salesforce consulting partner",
    "query": "site:appexchange.salesforce.com salesforce consulting partner \"@gmail.com\"",
    "title": "Northbridge CRM Consulting - Salesforce AppExchange",
    "accountName": "Northbridge CRM Consulting",
    "fullName": "Northbridge CRM Consulting",
    "username": null,
    "profileUrl": "",
    "url": "https://appexchange.salesforce.com/consulting",
    "description": "Certified Salesforce implementation partner. Enquiries: northbridge.crm@gmail.com",
    "email": "northbridge.crm@gmail.com",
    "emailDomain": "@gmail.com",
    "possiblyTruncated": false,
    "foundAt": "2026-08-31T11:21:08Z"
  },
  {
    "network": "Salesforce AppExchange",
    "keyword": "appexchange isv app",
    "query": "site:appexchange.salesforce.com appexchange isv app support \"@outlook.com\"",
    "title": "Quote Engine for Sales Cloud - Salesforce AppExchange",
    "accountName": "Quote Engine for Sales Cloud",
    "fullName": "",
    "username": "a0N3A00000ErHXXUA3",
    "profileUrl": "https://appexchange.salesforce.com/appxListingDetail?listingId=a0N3A00000ErHXXUA3",
    "url": "https://appexchange.salesforce.com/appxListingDetail?listingId=a0N3A00000ErHXXUA3",
    "description": "CPQ add-on for Sales Cloud. Partner support: quoteengine.partners@outlook.com or...",
    "email": "quoteengine.partners@outlook.com",
    "emailDomain": "@outlook.com",
    "possiblyTruncated": true,
    "foundAt": "2026-08-31T11:22:35Z"
  }
]
```

The first row is the common AppExchange shape: a real partner name and a working email, with `username: null` and an empty `profileUrl` because the listing id was not in the result.
The second row shows what a resolved id looks like — an opaque `a0N3A0000...` string, not a readable handle.
Note `possiblyTruncated: true` on that row: verify the address before sending.

### Use cases for the Salesforce AppExchange Email Scraper

| Use case | How the Salesforce AppExchange Email Scraper supports it |
|---|---|
| ISV partner recruitment | Find app publishers in adjacent categories and open a co-sell or bundling conversation |
| Consulting partner sourcing | Build a salesforce consulting partner contact list for implementation work you need delivered |
| Reseller and SI channel building | Identify system integrators already active in a vertical or region |
| Integration partnerships | Spot AppExchange apps whose customers would benefit from a two-way integration |
| Competitive and market research | Map who publishes in a category, with a contact route for interviews and surveys |
| Vendor due diligence | Collect direct enquiry addresses for partners you are evaluating |
| Event and community recruiting | Invite active partners to a webinar, roundtable or partner programme |
| Recruiting certified talent | Reach boutique consultancies whose listings advertise specific certifications |

Channel teams often widen the same motion with the [Zapier App Directory Email Scraper](https://apify.com/leads-scraper/zapier-app-directory-email-scraper) and the [Atlassian Marketplace Email Scraper](https://apify.com/leads-scraper/atlassian-marketplace-email-scraper), because integration vendors list across all three marketplaces.
These are B2B partner contacts, not consumer prospects.
Anchor your first line to the specific listing or cloud and the Salesforce AppExchange Email Scraper output behaves like a partner pipeline, not cold outbound.

### Tuning the Salesforce AppExchange Email Scraper for better yield

Broaden `customDomains` early. Salesforce partners are companies, so corporate domains matter more here than in developer marketplaces.
Add your target domains directly — `@acme.co.uk`, `consultingfirm.com` — alongside the free-mailbox defaults, since many boutique consultancies still list a Gmail contact.

Keep `expandQueries` on. Google caps a single query at roughly 300 results, and query expansion is how the Salesforce AppExchange Email Scraper reaches past that ceiling.
Add ecosystem words to `queryModifiers` — `partner`, `consultant`, `implementation`, `managed package`, `enquiries` — to open fresh query surface.

Use `countryCode` and `location` aggressively here, because partner selection is regional. A
run with `countryCode: "DE"` and `location: "Germany"` returns a materially different partner
set from a US-weighted run.

Raise `maxConcurrency` on paid plans; resumable state means a migrated run resumes rather than
restarts. For technical listings, the \[GitHub Email Scraper]\(https://apify.com/leads-
scraper/github-email-scraper) often enriches the same ISVs from their engineering side.

### Expected results and honest limitations of the Salesforce AppExchange Email Scraper

- **AppExchange listing URLs use opaque query-string ids, so most rows carry the partner email and listing name without a profile URL.** Expect `username: null` and `profileUrl: ""` on a large share of rows; the email and partner name are still there.
- The Salesforce AppExchange Email Scraper only finds partners whose email is **publicly visible in Google's index**. Listings that route contact through a form will not appear.
- Google caps a single query at roughly 300 results. Query expansion mitigates that; it does not remove it.
- `username` and `profileUrl` are populated only when Google's result exposes an identifier. Rows without one still carry `accountName` and `fullName` — a Google limitation, not a bug.
- `possiblyTruncated: true` means Google's snippet ellipsis touched the address. Verify those rows.
- The Actor requires the Apify **GOOGLE_SERP** proxy and cannot run without Apify proxy credentials.
- Free Apify plans are capped at **100 emails per run**; paid plans are uncapped.
- Results vary with keywords, domains, country and location. No volume is guaranteed.

The Salesforce AppExchange Email Scraper is not affiliated with, endorsed by or supported by Salesforce.
It reads public Google search results only.

### Legal and ethical use of Salesforce AppExchange Email Scraper output

The Actor collects public data; how you contact people is your responsibility.
A published partner enquiry address does not automatically create a lawful basis for bulk marketing under GDPR, CAN-SPAM or CASL — check yours before you send.
Identify yourself, keep the message specific to the partner's listing, and honour opt-outs on first request.

### FAQ about the Salesforce AppExchange Email Scraper

#### Why do so many Salesforce AppExchange Email Scraper rows have no profile URL?

Because AppExchange listing URLs use opaque query-string ids, so most rows carry the partner email and listing name without a profile URL. When Google does not print that id, `username` is `null` and `profileUrl` is empty. The email, partner name and description snippet are still populated.

#### Does the Salesforce AppExchange Email Scraper log into AppExchange or use the Salesforce API?

No. It never authenticates, never opens the marketplace and never uses a Salesforce API. It reads publicly indexed Google search results only.

#### Where do the emails the Salesforce AppExchange Email Scraper returns come from?

From the visible text of Google result blocks — titles, snippets and site labels — for pages on `appexchange.salesforce.com`.

#### Can the Salesforce AppExchange Email Scraper find consulting partners and ISVs in one run?

Yes. Put both kinds of terms in `keywords` — for example `salesforce consulting partner` and `appexchange isv app`. The `keyword` field on every row tells you which query produced the lead.

#### How many emails can one Salesforce AppExchange Email Scraper run return?

`maxEmails` accepts 1 to 10000. Free Apify plans stop at 100 emails per run; paid plans are uncapped. Real yield depends on your keywords and domain filter.

#### What does `possiblyTruncated` mean in Salesforce AppExchange Email Scraper output?

Google cut the snippet with an ellipsis right at the email, so the address may be incomplete. Treat those rows as needing verification before any send.

#### Can I schedule the Salesforce AppExchange Email Scraper?

Yes. Apify Schedules can re-run it on a cadence. Deduplication is per run, so diff each dataset against your CRM to catch newly listed appexchange ISV partner leads.

#### Can the Salesforce AppExchange Email Scraper target corporate domains?

Yes. Any domain goes into `customDomains`, with or without the `@`. Boundary-correct matching prevents false positives such as `@gmail.company`.

#### Do I need a proxy to run the Salesforce AppExchange Email Scraper?

Yes. It runs on the Apify GOOGLE_SERP proxy and will not work without Apify proxy credentials.

#### Is a Salesforce AppExchange Email Scraper run resumable?

Yes. State is persisted in the key-value store keyed by a hash of your input and saved on Apify's `PERSIST_STATE`, `MIGRATING` and `ABORTING` events.

#### Why did my Salesforce AppExchange Email Scraper run return fewer results than expected?

Usually a narrow domain filter or overly generic keywords. Broaden `customDomains`, add ecosystem terms to `queryModifiers`, and keep `expandQueries` enabled.

#### Are these consumer contacts?

No. They are ISV partners, consultancies and system integrators who published a contact address on a commercial listing. Frame outreach as partnership, not consumer prospecting.

#### How do I export Salesforce AppExchange Email Scraper results?

Through the standard Apify dataset export: JSON, CSV, Excel, XML or the Apify API.

### Related Actors

| Actor | What it collects |
|---|---|
| [Salesforce AppExchange Email and Phone Number Scraper](https://apify.com/neuro-scraper/salesforce-appexchange-email-and-phone-number-scraper) | Emails and phone numbers from Salesforce AppExchange |
| [Salesforce AppExchange Phone Number Scraper](https://apify.com/neuro-scraper/salesforce-appexchange-phone-number-scraper) | Public phone numbers from Salesforce AppExchange |
| [App Store Email Scraper](https://apify.com/leads-scraper/app-store-email-scraper) | Public contact emails from App Store |
| [Atlassian Marketplace Email Scraper](https://apify.com/leads-scraper/atlassian-marketplace-email-scraper) | Public contact emails from Atlassian Marketplace |
| [Bitbucket Email Scraper](https://apify.com/neuro-scraper/bitbucket-email-scraper) | Public contact emails from Bitbucket |
| [Chrome Web Store Email Scraper](https://apify.com/leads-scraper/chrome-web-store-email-scraper) | Public contact emails from Chrome Web Store |
| [CodePen Email Scraper](https://apify.com/neuro-scraper/codepen-email-scraper) | Public contact emails from CodePen |
| [Confluence Email Scraper](https://apify.com/neuro-scraper/confluence-email-scraper) | Public contact emails from Confluence |
| [Dev.to Email Scraper](https://apify.com/neuro-scraper/dev-to-email-scraper) | Public contact emails from DEV Community |
| [Docker Hub Email Scraper](https://apify.com/neuro-scraper/docker-hub-email-scraper) | Public contact emails from Docker Hub |
| [Figma Community Email Scraper](https://apify.com/neuro-scraper/figma-community-email-scraper) | Public contact emails from Figma Community |
| [Firefox Add-ons Email Scraper](https://apify.com/neuro-scraper/firefox-add-ons-email-scraper) | Public contact emails from Firefox Add-ons |
| [GitHub Email Scraper](https://apify.com/leads-scraper/github-email-scraper) | Public contact emails from GitHub |
| [GitLab Email Scraper](https://apify.com/neuro-scraper/gitlab-email-scraper) | Public contact emails from GitLab |
| [Google Play Email Scraper](https://apify.com/leads-scraper/google-play-email-scraper) | Public contact emails from Google Play |
| [Hashnode Email Scraper](https://apify.com/neuro-scraper/hashnode-email-scraper) | Public contact emails from Hashnode |
| [HubSpot Marketplace Email Scraper](https://apify.com/leads-scraper/hubspot-marketplace-email-scraper) | Public contact emails from HubSpot Marketplace |
| [Hugging Face Email Scraper](https://apify.com/leads-scraper/hugging-face-email-scraper) | Public contact emails from Hugging Face |
| [Jira Email Scraper](https://apify.com/neuro-scraper/jira-email-scraper) | Public contact emails from Jira |
| [Maven Central Email Scraper](https://apify.com/neuro-scraper/maven-central-email-scraper) | Public contact emails from Maven Central |
| [Microsoft AppSource Email Scraper](https://apify.com/neuro-scraper/microsoft-appsource-email-scraper) | Public contact emails from Microsoft AppSource |
| [Shopify App Store Email Scraper](https://apify.com/leads-scraper/shopify-app-store-email-scraper) | Public contact emails from Shopify App Store |
| [Slack App Directory Email Scraper](https://apify.com/leads-scraper/slack-app-directory-email-scraper) | Public contact emails from Slack App Directory |
| [SourceForge Email Scraper](https://apify.com/leads-scraper/sourceforge-email-scraper) | Public contact emails from SourceForge |
| [Stack Overflow Email Scraper](https://apify.com/leads-scraper/stack-overflow-email-scraper) | Public contact emails from Stack Overflow |
| [Unity Asset Store Email Scraper](https://apify.com/leads-scraper/unity-asset-store-email-scraper) | Public contact emails from Unity Asset Store |
| [Unreal Engine Marketplace Email Scraper](https://apify.com/leads-scraper/unreal-engine-marketplace-email-scraper) | Public contact emails from Unreal Engine Marketplace |
| [WordPress Plugin Directory Email Scraper](https://apify.com/neuro-scraper/wordpress-plugin-directory-email-scraper) | Public contact emails from WordPress Plugin Directory |
| [WordPress Theme Directory Email Scraper](https://apify.com/leads-scraper/wordpress-theme-directory-email-scraper) | Public contact emails from WordPress Theme Directory |
| [Zapier App Directory Email Scraper](https://apify.com/leads-scraper/zapier-app-directory-email-scraper) | Public contact emails from Zapier App Directory |
| [App Store Email and Phone Number Scraper](https://apify.com/leads-scraper/app-store-email-and-phone-number-scraper) | Emails and phone numbers from App Store |
| [Atlassian Marketplace Email and Phone Number Scraper](https://apify.com/neuro-scraper/atlassian-marketplace-email-and-phone-number-scraper) | Emails and phone numbers from Atlassian Marketplace |
| [Bitbucket Email and Phone Number Scraper](https://apify.com/neuro-scraper/bitbucket-email-and-phone-number-scraper) | Emails and phone numbers from Bitbucket |
| [Chrome Web Store Email and Phone Number Scraper](https://apify.com/neuro-scraper/chrome-web-store-email-and-phone-number-scraper) | Emails and phone numbers from Chrome Web Store |
| [CodePen Email and Phone Number Scraper](https://apify.com/neuro-scraper/codepen-email-and-phone-number-scraper) | Emails and phone numbers from CodePen |
| [Confluence Email and Phone Number Scraper](https://apify.com/neuro-scraper/confluence-email-and-phone-number-scraper) | Emails and phone numbers from Confluence |
| [DEV Community Email and Phone Number Scraper](https://apify.com/neuro-scraper/dev-to-email-and-phone-number-scraper) | Emails and phone numbers from DEV Community |
| [Docker Hub Email and Phone Number Scraper](https://apify.com/neuro-scraper/docker-hub-email-and-phone-number-scraper) | Emails and phone numbers from Docker Hub |
| [Figma Community Email and Phone Number Scraper](https://apify.com/neuro-scraper/figma-community-email-and-phone-number-scraper) | Emails and phone numbers from Figma Community |
| [Firefox Add-ons Email and Phone Number Scraper](https://apify.com/neuro-scraper/firefox-add-ons-email-and-phone-number-scraper) | Emails and phone numbers from Firefox Add-ons |
| [GitHub Email and Phone Number Scraper](https://apify.com/leads-scraper/github-email-and-phone-number-scraper) | Emails and phone numbers from GitHub |
| [GitLab Email and Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-email-and-phone-number-scraper) | Emails and phone numbers from GitLab |

### Leave a review

If the Salesforce AppExchange Email Scraper saved you time, please leave a star rating and a
short review on the Actor page.

Reviews are how other buyers judge whether a tool works, and they tell us which features to
build next.

If something did not work, email <neurodata.apify@gmail.com>
instead - bugs get fixed faster than they get complained about.

### Support

Questions, a bug report or a custom build of the Salesforce AppExchange Email Scraper? Email **neurodata.apify@gmail.com**.

# Actor input Schema

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

Search terms describing the Salesforce AppExchange accounts you want (niche, job title, industry).

## `location` (type: `string`):

Optional location phrase added to every query (e.g. "New York").

## `customDomains` (type: `array`):

Only emails ending with one of these domains are collected. With or without the leading @. Each domain is searched separately, so more domains means more results but a longer run - remove some for a faster, narrower search, or add your own (e.g. @company.com).

## `maxEmails` (type: `integer`):

Stop once this many unique emails have been collected.

## `countryCode` (type: `string`):

Two-letter country code for the search proxy (e.g. US, GB, DE). Empty for any.

## `expandQueries` (type: `boolean`):

Search each keyword x domain pair with several phrasings. Recommended - Google caps a single query at ~300 results.

## `queryModifiers` (type: `array`):

Extra words combined with each keyword when Expand queries is on. Tuned for Salesforce AppExchange.

## `maxPagesPerQuery` (type: `integer`):

Google rarely returns more than ~30 pages for one query.

## `maxConcurrency` (type: `integer`):

How many queries run in parallel.

## Actor input object example

```json
{
  "keywords": [
    "salesforce partner",
    "consulting"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20,
  "countryCode": "",
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "support",
    "developer",
    "publisher"
  ],
  "maxPagesPerQuery": 30,
  "maxConcurrency": 5
}
```

# Actor output Schema

## `results` (type: `string`):

Records produced by Salesforce AppExchange Email Scraper, stored in the run's default dataset.

# 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 = {
    "keywords": [
        "salesforce partner",
        "consulting"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "support",
        "developer",
        "publisher"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("leads-scraper/salesforce-appexchange-email-scraper").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 = {
    "keywords": [
        "salesforce partner",
        "consulting",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
    "countryCode": "",
    "queryModifiers": [
        "email",
        "contact",
        "support",
        "developer",
        "publisher",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("leads-scraper/salesforce-appexchange-email-scraper").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 '{
  "keywords": [
    "salesforce partner",
    "consulting"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "countryCode": "",
  "queryModifiers": [
    "email",
    "contact",
    "support",
    "developer",
    "publisher"
  ]
}' |
apify call leads-scraper/salesforce-appexchange-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leads-scraper/salesforce-appexchange-email-scraper"
        }
    }
}
```

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/4dNVTDKZRnQvddeHA/builds/Xh2eHhhmYihgAaWob/openapi.json