# Gofundme Email Scraper Fast Advanced And Cheapest (`solid-scraper/gofundme-email-scraper-fast-advanced-and-cheapest`) Actor

📧 Gofundme Email Scraper (Fast • Advanced • Cheapest) extracts verified fundraiser emails quickly—filter by campaign/category for targeted outreach. 🚀 Perfect for lead gen, nonprofits, agencies & sales teams. Save time, boost conversions. 💰

- **URL**: https://apify.com/solid-scraper/gofundme-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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.

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

### Gofundme Email Scraper - Fast, Advanced and Cheapest

**Gofundme Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that extracts email addresses from GoFundMe using the keywords and filters you choose. It helps marketers and researchers automatically build a **GoFundMe donor email extractor** or **GoFundMe outreach email list**—so you can spend less time searching manually and move faster to outreach at scale.

Whether you’re building a **GoFundMe campaign email list**, running **mass GoFundMe email scraping** for lead qualification, or assembling contact data for fundraising communications, this actor focuses on pulling **emails from publicly available sources** and storing results in a structured dataset for easy export and analysis.

***

### Why choose Gofundme Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
|---|---|
| ✅ **Email extraction from GoFundMe** | Quickly collects emails associated with results relevant to your keywords and domains |
| ✅ **Keyword and domain targeting** | Improves lead relevance by using targeted keywords and custom email-domain filters |
| ✅ **Resumable progress** | Continues from where it left off using saved cursor and already-seen emails |
| ✅ **Max email collection control** | Stops once `maxEmails` is reached to manage scraping time and costs |
| ✅ **Structured dataset rows** | Outputs consistent records with `keyword`, `title`, `description`, `url`, and `email` |
| ✅ **Scalable automation workflow** | Designed for running across multiple keywords and email domains in a single job |

***

### Key features

- 🔍 **Targeted GoFundMe email discovery**: Uses your provided keywords to find relevant GoFundMe leads and extracts emails that match your chosen domains.
- 🎯 **Custom email-domain filters**: Focuses extraction using your `customDomains` (for example `@gmail.com`, `@yahoo.com`) to find emails you can actually use.
- 🔄 **Resumable scraping progress**: Saves progress (keyword/domain cursor + seen emails) so long runs can continue reliably.
- 🛡️ **Reliability-minded execution**: Includes resilience patterns and stopping logic when it stops producing new emails.
- 📊 **Incremental dataset saving**: Pushes each found lead as a dataset row immediately, reducing the risk of losing work.
- 💾 **Clean, table-friendly output**: Dataset output is structured for easy review in the Apify UI.
- ⏱️ **Controlled run length**: Lets you set `maxEmails` to cap output volume and keep runs cost-effective.
- 🌍 **Optional location filtering**: Adds a location filter when you provide `location` in your input.

***

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["manager", "founder"],
  "location": "New York, NY",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

#### Input Fields

| Field | Required | Description |
|---|---:|---|
| `keywords` | ✅ | A list of keywords or queries used to find relevant GoFundMe results. Used as the basis for extracting emails (e.g., for **GoFundMe donor email extractor** workflows). |
| `location` | ❌ | A location string used to filter results. Leave empty if you want broader coverage. |
| `customDomains` | ❌ | A list of email domains (like `@gmail.com`, `@yahoo.com`) that the scraper uses as a filter for extracting emails. |
| `maxEmails` | ❌ | Maximum number of emails to collect. The scraper stops once this limit is reached. Higher limits may take longer and do not guarantee reaching the target number. |

***

### Output

The actor saves each found lead as a dataset row in JSON format.

Example dataset row:

```json
{
  "network": "Gofundme.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | The source network label used in the dataset (`"Gofundme.com"`). |
| `keyword` | string | The keyword from your input that led to this result. |
| `title` | string | Result title text as captured from the listing. |
| `description` | string | Text content extracted from the result snippet (where available). |
| `url` | string | The associated URL captured from the listing. |
| `email` | string | The extracted email address that matched your domain filter. |

Notes:

- The actor pushes rows incrementally to the dataset as it discovers new emails.
- There is no dedicated `error_message` field in the dataset output defined by the actor—errors are handled via logging and run behavior.

***

### How to use Gofundme Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**
   Log in at https://console.apify.com and open the Actors page.

2. **Find the actor**
   Search for **Gofundme Email Scraper - Fast, Advanced and Cheapest** and open its details.

3. **Go to the INPUT panel**
   Paste your `input.json` values in the built-in input editor.

4. **Set your keywords**
   Enter a list in `keywords` (required). These drive the **GoFundMe email finder** behavior for different lead angles like **manager** and **founder**.

5. **Optional: narrow by location**
   Add a string to `location` if you want results filtered to a specific region; otherwise keep it empty for broader coverage.

6. **Optional: filter by email domains**
   Update `customDomains` (like `@gmail.com`, `@yahoo.com`) to target emails you can use for outreach—this is especially useful for **GoFundMe campaign email list** building.

7. **Optional: cap output with maxEmails**
   Set `maxEmails` to control how many emails to collect before stopping. If you don’t set it, the actor uses a default of `20` in the input schema.

8. **Run and monitor logs**
   Start the run. You’ll see logs while it processes your keyword/domain combinations and pushes results as they’re found.

9. **Access results in the dataset**
   When the run finishes, open the dataset in the **OUTPUT** tab and export to your preferred format (JSON/CSV via Apify dataset exports).

No coding required—get **GoFundMe email scraper** results in minutes.

***

### Advanced features & SEO optimization

- 🔄 **Resumable long runs**: Maintains a saved cursor (keyword/domain position) and a set of already-seen emails, so you can pause/resume without restarting from scratch.
- 🎯 **Engineered for GoFundMe outreach email list building**: Specifically designed to excel at **GoFundMe donor email extractor** and **GoFundMe fundraising contact scraper** workflows using your keyword and domain filters.
- 📊 **Structured, export-ready output**: Each pushed dataset row contains consistent fields (`keyword`, `title`, `description`, `url`, `email`) for easy analysis and CRM ingestion.
- 💾 **Incremental saving for safety**: Emails are pushed to the dataset as they are discovered, helping reduce the impact of interruptions.
- 🛡️ **Stop conditions to manage efficiency**: Uses stopping logic based on `maxEmails` and periods with no new emails, helping you avoid endless runs.

***

### Best use cases

- 📈 **Lead generation for fundraising outreach**: Build a **GoFundMe outreach email list** by extracting emails tied to relevant keyword-focused results for faster campaign execution.
- 💌 **Donor and organizer research**: Gather **GoFundMe fundraising contact scraper** data to support research into who runs campaigns and who may be reachable for partnerships.
- 🧠 **Data enrichment for analysts**: Combine the structured `keyword`, `url`, and `email` fields to analyze lead patterns across different search angles.
- 🗂️ **Mass contact list building**: Use **mass GoFundMe email scraping** for batch workflows where you need many leads quickly—then deduplicate and segment downstream.
- 🏷️ **Niche targeting by email domain**: Improve deliverability planning by extracting only emails matching your `customDomains` (useful for **GoFundMe donor email extractor** quality control).
- 💼 **CRM pipeline automation**: Feed extracted rows into your CRM or outreach tooling as structured records with consistent keys (great for pipeline automation).
- 🔎 **GoFundMe email finder for specific roles**: Search for roles like **manager** and **founder** to find contacts that align with your outreach messaging.

***

### Technical specifications

- **Supported Input Formats**
  - ✅ `keywords` as an array of strings (required)
  - ✅ `location` as a string (optional)
  - ✅ `customDomains` as an array of strings (optional)
  - ✅ `maxEmails` as an integer with bounds (`minimum: 1`, `maximum: 10000`)

- **Proxy Support**
  - ✅ Built-in proxy support for more reliable scraping runs

- **Retry Mechanism**
  - ✅ Includes resilience and stopping logic intended to handle pages that return no results

- **Dataset Structure**
  - ✅ Each dataset row includes: `network`, `keyword`, `title`, `description`, `url`, `email`

- **Limitations**
  - ❌ Results are limited by stopping rules (not every run will reach `maxEmails`)
  - ❌ Output depends on what matching publicly available sources contain (emails may not exist for every result)

- **Rate Limits & Performance**
  - Runs can take longer with higher limits and wider coverage; use `maxEmails` to control job duration.

***

### FAQ

#### Is Gofundme Email Scraper - Fast, Advanced and Cheapest able to extract emails from all GoFundMe pages?

❌ Not necessarily. The actor only extracts emails that match your provided `customDomains` and that are present in the publicly available text content it processes. If a result doesn’t contain matching email patterns, it won’t produce an `email` for that row.

#### What input fields are required to run Gofundme Email Scraper - Fast, Advanced and Cheapest?

✅ Only `keywords` is required. The `location`, `customDomains`, and `maxEmails` fields are optional, but they can significantly improve targeting for a **GoFundMe campaign email list** or **GoFundMe donor email extractor** use case.

#### Can I limit how many emails the actor collects?

✅ Yes. Use `maxEmails` to set a maximum number of emails to collect. The scraper stops once it reaches that limit, which helps keep runs efficient.

#### Does the actor save results as it goes?

✅ Yes. The actor pushes each found record to the dataset incrementally, so you can monitor progress and reduce the risk of losing work if the run stops early.

#### Can I resume a stopped run without redoing everything?

✅ Yes. The actor persists progress using a saved cursor and a list of already-seen emails, so it can continue from where it left off.

#### Does Gofundme Email Scraper - Fast, Advanced and Cheapest support location targeting?

✅ Yes. If you set `location`, the actor applies that filter while searching for relevant results before extracting matching emails.

#### Can I export the output for use in marketing tools?

✅ Yes. Results are stored in the Apify dataset, which you can export (for example as JSON/CSV) for downstream workflows like CRM import or analysis.

***

### Support & feature requests

If you’re using **Gofundme Email Scraper - Fast, Advanced and Cheapest** for **GoFundMe email scraper** projects and want improvements, we’d love to hear from you.

- 💡 **Feature Requests**: Tell us what you want next—for example, enhancements for CSV export workflows, richer output fields, or refined email-domain filtering behavior.
- 📧 **Contact**: Email us at <dataforleads@gmail.com>.

Your feedback helps shape the roadmap for **GoFundMe email finder** and **outreach email list** use cases.

***

### Disclaimer

**This tool only accesses publicly accessible sources**. It does not access private profiles, authenticated data, or password-protected content.

You are responsible for complying with applicable laws (including GDPR/CCPA where relevant), spam regulations, and each platform’s Terms of Service. For data removal requests, contact <dataforleads@gmail.com>.

Use **Gofundme Email Scraper - Fast, Advanced and Cheapest** responsibly, ethically, and only for legitimate purposes.

*Get the most comprehensive, SEO-optimized Gofundme Email Scraper - Fast, Advanced and Cheapest experience for your outreach and research workflows.*

# Actor input Schema

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

A list of keywords or queries to search for.

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

Location to filter search results.

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

List of custom email domains

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

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/gofundme-email-scraper-fast-advanced-and-cheapest").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": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/gofundme-email-scraper-fast-advanced-and-cheapest").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call solid-scraper/gofundme-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solid-scraper/gofundme-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8daU9a5WgLk5DNSBF/builds/6p19ZjgWIuOLw2X2c/openapi.json