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

GoFundMe Email Scraper collects public campaign contact emails by keyword, location or custom domain, returning network, keyword, title, description, URL and email. 💌 For fundraising outreach, nonprofit research and donor prospecting.

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

## Pricing

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

### 📧 GoFundMe Email Scraper – Fast, Advanced & Cheapest Contact Extraction

The **GoFundMe Email Scraper** finds publicly listed email addresses associated with GoFundMe campaign pages and returns them as clean, structured records containing the email, the campaign title, the page description snippet, the source URL and the keyword that produced the match. It is built for teams who need contact data from public fundraising pages without maintaining their own search infrastructure, proxy pool or parsing layer.

Rather than crawling GoFundMe directly, this GoFundMe email scraper works through public search results using site-restricted search operators. It combines every keyword you supply with every email domain you supply, walks the result pages, and pulls out any address matching your chosen domain patterns from the visible titles and description snippets. The result is a de-duplicated email list you can export to CSV, push into a CRM, or feed straight into an outreach sequence.

Because the scraper only reads publicly indexed search results, everything it returns is information already visible to anyone running the same search by hand — just collected at a scale and consistency that manual work cannot match.

***

### 📊 What Data Can You Extract with This GoFundMe Email Scraper?

Every dataset row represents one unique email address discovered in the public search index, together with the context that surrounded it.

| Category | Fields | What it gives you |
|---|---|---|
| 📬 Contact data | `email` | The unique email address extracted from the search result, matched against your configured domain patterns |
| 🔍 Search provenance | `keyword`, `network` | The exact keyword that produced this match and the source network the record came from |
| 🏷️ Page identity | `title`, `url` | The result title as displayed in the search listing and the link to the underlying public page |
| 📝 Context | `description` | The visible description text from the search result — the passage the email was actually extracted from |

The field that quietly does the most work here is `keyword`. Because every row records which of your search terms produced it, you can measure yield per keyword after a run and drop the terms that return nothing. Over a few iterations that turns a broad, wasteful keyword list into a tight, high-yield one — and on a pay-per-result Actor, keyword efficiency translates directly into cost efficiency.

The `description` field is equally useful for qualification: it is the raw context the address appeared in, so you can filter out matches that are clearly irrelevant before any of them reach an outreach tool.

***

### 🌟 Key Features of the GoFundMe Email Scraper

| Feature | Description |
|---|---|
| 🔑 Multi-keyword search | Supply any number of keywords; each one is searched separately and tagged in the output so you can attribute every result back to its source term |
| 🌐 Custom email domain targeting | The `customDomains` list controls which address patterns are matched — `@gmail.com` by default, but you can target `@outlook.com`, `@yahoo.com`, or company domains for B2B prospecting |
| 📍 Optional location filter | Add a `location` string and it is appended to every search query, narrowing results to campaigns mentioning that place |
| 🔁 Automatic de-duplication | A running set of seen addresses means the same email is never pushed twice, no matter how many keyword and domain combinations surface it |
| 💾 Resumable progress state | Progress — the keyword/domain cursor and the set of emails already found — is persisted during the run, so an interrupted run picks up where it left off instead of starting over |
| 🎯 Hard result cap | Set `maxEmails` and the scraper stops cleanly the moment that many unique addresses have been collected, giving you predictable run size |
| 🚦 Smart stop detection | The scraper monitors yield across recent pages and stops walking a query once results dry up, rather than grinding through empty pages |
| 🔄 Automatic proxy rotation | Search requests are routed through rotating proxy infrastructure automatically — nothing to configure, no credentials to supply |
| 📤 Incremental dataset writes | Every email is pushed to the dataset as it is found, so partial results are available immediately and survive an interrupted run |

***

### 🚀 Why Choose This GoFundMe Email Scraper?

**Every result carries its own provenance.** A bare list of email addresses is almost impossible to qualify. Here each record ships with the `keyword` that found it, the `title` and `url` of the page, and the `description` passage the address appeared in — so you can judge relevance before you contact anyone, and audit where any given address came from.

**Keyword and domain coverage is fully combinatorial.** The scraper runs every keyword against every entry in `customDomains`, so three keywords and five domains produce fifteen distinct searches. That multiplies your coverage of the public index without you having to construct and monitor each query manually.

**Runs are resumable, not disposable.** Progress state — where the scraper is in the keyword/domain matrix and which addresses it has already seen — is persisted as the run proceeds. If a run is interrupted, restarting continues from the cursor rather than repeating work and re-charging for duplicates.

**Cost is bounded by design.** `maxEmails` sets a hard ceiling on unique results, and the built-in stop detection abandons queries that have stopped yielding. Together they mean a run costs what you expect it to cost, instead of burning through hundreds of low-value pages.

***

### 📥 Input

```json
{
  "keywords": ["medical", "education"],
  "customDomains": ["@gmail.com", "@outlook.com"],
  "location": "California",
  "maxEmails": 200
}
```

#### 🔧 GoFundMe Email Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | array | No | `["john"]` | List of search keywords. Each keyword is combined with every entry in `customDomains` to build a separate search query, and the matching keyword is recorded on each output row |
| `customDomains` | array | No | `["@gmail.com"]` | Email domain patterns to search for and match against, e.g. `@gmail.com`, `@outlook.com`, `@yahoo.com`, or a specific company domain |
| `location` | string | No | `""` | Optional location term appended to every search query. Leave empty for no geographic narrowing |
| `maxEmails` | integer | No | *(no limit)* | Maximum number of unique email addresses to collect. When omitted the scraper runs until the keyword/domain matrix is exhausted |

> **Note on account plans:** when the Actor runs on the Apify platform under a free account, the result count is capped at 100 unique emails per run regardless of the `maxEmails` value you supply. Paid accounts run without that cap.

#### 💡 Input Examples

**Small qualified test run:**

```json
{
  "keywords": ["cancer treatment"],
  "customDomains": ["@gmail.com"],
  "maxEmails": 50
}
```

**Broad multi-domain sweep:**

```json
{
  "keywords": ["medical bills", "surgery fund", "hospital"],
  "customDomains": ["@gmail.com", "@yahoo.com", "@outlook.com", "@hotmail.com"],
  "maxEmails": 500
}
```

**Location-targeted campaign search:**

```json
{
  "keywords": ["animal rescue", "shelter"],
  "customDomains": ["@gmail.com"],
  "location": "Texas",
  "maxEmails": 150
}
```

***

### 📤 Output

```json
{
  "network": "Gofundme.com",
  "keyword": "medical",
  "title": "Help Cover Emergency Medical Bills",
  "description": "Our family is raising funds after an unexpected hospital stay. For questions please reach out to example.contact@gmail.com — thank you for your support.",
  "url": "https://www.gofundme.com/f/help-cover-emergency-medical-bills",
  "email": "example.contact@gmail.com"
}
```

#### 🧾 GoFundMe Email Output Fields

| Field | Type | Description |
|---|---|---|
| `network` | string | null | Network of the item |
| `keyword` | string | null | Keyword that produced this item |
| `title` | string | null | Title of the item |
| `description` | string | null | Long-form description text |
| `url` | string | null | Canonical URL of the scraped item |
| `email` | string | null | Email address found for the item |

Each row is one unique email address. Because de-duplication runs across the whole job, an address that appears under several keywords is written once only — attributed to the first keyword that surfaced it.

***

### 💻 How to Use the GoFundMe Email Scraper (Step by Step)

#### Step 1: Choose Keywords That Match Your Audience

Keywords are the single biggest lever on result quality. Think about the words that would actually appear in the campaigns you want to reach — a cause type such as "animal rescue", a situation such as "medical bills", or an organisation type such as "nonprofit". Broad, generic single words return volume but poor relevance; two- or three-word phrases return fewer results with much better fit. Start with three to five candidate keywords rather than twenty, so you can measure which ones actually earn their place.

#### Step 2: Configure the Email Domains You Want to Match

`customDomains` defaults to `["@gmail.com"]`, which is the highest-volume consumer provider and a sensible starting point. Adding `@outlook.com`, `@yahoo.com`, `@hotmail.com` and `@icloud.com` broadens coverage substantially, because each domain triggers its own set of searches. If you are prospecting for business contacts rather than individuals, add specific company domains instead — the matcher works on whatever patterns you give it.

#### Step 3: Decide Whether to Narrow by Location

The optional `location` string is appended to every query, so setting it to a state, city or country tightens results to campaigns that mention that place. This is powerful for regional outreach but it also cuts result volume sharply, since the location term must appear in the indexed text. If a location-filtered run returns very little, drop the filter and post-filter the results yourself using the `description` field.

#### Step 4: Set a Sensible `maxEmails` Ceiling

Because this Actor charges per result, `maxEmails` is your cost control. Set it deliberately for every run rather than leaving it open. For a first pass at a new keyword set, a small ceiling of 50 to 100 tells you whether the keywords are productive before you spend more. Once you know a configuration works, raise the ceiling for the full harvest. Remember that free Apify accounts are capped at 100 unique emails per run regardless of this setting.

#### Step 5: Start the Run and Follow the Log

Launch the Actor from the console or the API. The log reports which keyword and domain pair is being processed, how many new emails each pair produced, and when the scraper decides to stop walking a query because yield has dried up. This running commentary is the fastest way to see which parts of your configuration are working. Results are pushed to the dataset incrementally, so you can inspect early rows while the run is still going.

#### Step 6: Review, De-duplicate Against Your CRM, and Qualify

Open the dataset and read the `description` column before doing anything else. It is the passage each address was extracted from, and it tells you immediately whether a match is genuinely relevant or an incidental appearance. Cross-reference the `email` column against contacts you already hold so you do not re-approach existing relationships, and use `url` to open any campaign whose context is ambiguous.

#### Step 7: Refine Your Keywords and Re-run

Group the finished dataset by `keyword` and count rows per group. Keywords producing few or irrelevant results should be replaced, not repeated. Keywords producing dense, well-qualified matches deserve variations and synonyms. Two or three cycles of this measure-and-refine loop typically produce a keyword set that yields several times more usable contacts per run than the initial guess did.

***

### 🔌 API Access & Integrations

Trigger the GoFundMe Email Scraper and get results back in one synchronous call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~gofundme-email-scraper-fast-advanced-and-cheapest/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["medical", "education"],
    "customDomains": ["@gmail.com", "@outlook.com"],
    "location": "California",
    "maxEmails": 200
  }'
```

Drive it from Python with the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run_input = {
    "keywords": ["animal rescue", "shelter"],
    "customDomains": ["@gmail.com", "@yahoo.com"],
    "location": "",
    "maxEmails": 150,
}

run = client.actor(
    "scrapers-hub/gofundme-email-scraper-fast-advanced-and-cheapest"
).call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["email"], "|", item["keyword"], "|", item["url"])
```

Finished runs can also be wired to Zapier, Make, Google Sheets, Slack or a custom webhook, so new email records flow into your CRM or outreach tool without a manual export step.

***

### 💡 Best Use Cases for GoFundMe Email Data

#### 🎗️ Nonprofit and Cause-Based Outreach

Charities and cause-driven organisations often need to reach people already engaged with a specific issue. Filtering by cause keywords and reading the `description` and `title` of each result identifies campaigns aligned with your mission, and `email` gives you a route to a conversation with people who have already demonstrated interest in that cause.

#### 🤝 Partnership and Sponsorship Prospecting

Brands looking to sponsor grassroots causes can use keyword-targeted runs to surface active campaigns in a category. The `url` field takes you to the public campaign page so you can assess fit and scale before reaching out, and `keyword` tells you which of your target categories produced the lead.

#### 📋 Market and Sector Research

Aggregating `title` and `description` text across a large keyword sweep produces a readable picture of what people in a given category are fundraising for and how they describe their situation. Grouping by `keyword` shows which framings are most common, which is useful input for messaging research even before any contact takes place.

#### 🧭 Lead List Building for Service Providers

Service businesses — from medical billing advocates to event organisers — can assemble targeted prospect lists by choosing keywords that match the situations their service addresses. The combination of `email` for contact and `description` for context means every lead arrives with enough background to personalise the first message rather than sending a generic blast.

#### 🔎 Contact Discovery for Journalists and Researchers

Reporters and academics researching a topic frequently need to reach the people directly involved. Keyword-driven runs surface relevant public campaigns, `url` provides the primary source to cite or verify against, and `email` offers a published route to request an interview or consent for a study.

#### 📊 Keyword Yield Testing for Campaign Planning

Because every row records its originating `keyword`, a deliberately broad run doubles as a research exercise. Counting results per keyword reveals which terms have real depth in the public index and which do not — intelligence you can apply to search advertising and content planning well beyond this Actor.

#### 🌍 Regional Targeting for Local Campaigns

Setting `location` to a city, state or country restricts results to campaigns mentioning that place, which suits organisations whose work is geographically bounded. Combining a regional `location` with cause keywords produces a focused local contact list rather than a diffuse national one.

***

### ⚙️ Tips for Better GoFundMe Email Scraping Results

- **Add more email domains before adding more keywords.** Each extra entry in `customDomains` multiplies your query count against the keywords you already have, and consumer providers such as `@outlook.com`, `@yahoo.com` and `@hotmail.com` are usually the fastest way to lift yield.
- **Use specific phrases, not single generic words.** "medical bills" and "surgery fund" produce far more relevant matches than "help" or "fund" on their own, because the public index rewards specificity.
- **Set `maxEmails` on every run.** It is the direct lever on cost and run length. Test a new configuration with a small ceiling, then raise it once you have confirmed the keywords produce usable results.
- **Loosen the `location` filter if results are thin.** A location term has to appear in the indexed text to match. When a regional run underperforms, remove the filter and filter afterwards on the `description` field instead.
- **Measure yield per keyword after every run.** Group the dataset by `keyword`, count the rows, and prune the terms that contributed little. This single habit improves cost per usable contact more than anything else.
- **Verify addresses before any outreach.** Emails harvested from public text can include stale, role-based or mistyped addresses. Run the list through a verification service and respect all applicable consent and unsubscribe obligations before contacting anyone.

***

### 🛠️ Troubleshooting

**The run finished with far fewer emails than I asked for.**
The scraper stops when the keyword/domain matrix is exhausted or when recent pages stop yielding new addresses — it does not invent results to hit your target. Broaden `customDomains` with additional providers, add related keywords, and remove the `location` filter if one is set. The run log prints exactly these suggestions along with your current configuration when results fall short of `maxEmails`.

**I hit a hard stop at 100 emails even though `maxEmails` was higher.**
That is the free-account limit applied when the Actor runs on the Apify platform under a non-paying plan. The log states clearly when this cap has been applied. A paid Apify plan removes it and the run will honour your configured `maxEmails` instead.

**Some `description` values say "No data" or the title says "No URL".**
Those placeholders appear when a search result renders without the expected snippet or link element. The email itself is still valid where one was extracted, but with no surrounding context you should verify the match against the `url` before using it.

**The same email appears in my exports from two separate runs.**
De-duplication is scoped to a single run's progress state, not across runs. If you launch several runs with overlapping keywords you will see repeats between them. De-duplicate on the `email` column after export, or keep a master suppression list in your CRM.

**Results are dominated by one keyword and the others returned nothing.**
That is a genuine signal about the public index rather than a fault. Replace the unproductive terms with more specific phrasings or closely related synonyms, and re-run. Grouping the previous dataset by `keyword` shows you exactly which terms to keep.

***

### ❓ Frequently Asked Questions About GoFundMe Email Scraping

**What does the GoFundMe Email Scraper actually collect?**
It collects publicly indexed email addresses associated with GoFundMe campaign pages, along with the campaign title, the visible description snippet the address appeared in, the page URL, the keyword that produced the match, and the source network label.

**How does the scraper find email addresses?**
It builds site-restricted search queries from each combination of your `keywords` and `customDomains`, walks the public search result pages, and extracts any address matching your configured domain patterns from the visible titles and descriptions. It reads results that are already publicly indexed.

**Do I need to supply proxies or credentials?**
No. Proxy rotation is handled automatically inside the Actor and there is no proxy configuration field. You supply keywords, domains and an optional location, and the search infrastructure is taken care of.

**How many emails can this GoFundMe scraper return per run?**
That depends on `maxEmails`, your keyword and domain breadth, and how deep the public index goes for those queries. Free Apify accounts are capped at 100 unique emails per run; paid accounts run to whatever `maxEmails` you set, or until the query matrix is exhausted.

**Can I search for email domains other than Gmail?**
Yes. `customDomains` accepts any list of domain patterns. Adding `@outlook.com`, `@yahoo.com`, `@hotmail.com` and `@icloud.com` widens consumer coverage, and adding specific company domains targets business contacts instead.

**Will the same email address appear more than once?**
Not within a single run. A set of already-seen addresses is maintained throughout the job, so each unique email is written to the dataset exactly once, attributed to the keyword that first surfaced it. Repeats can occur across separate runs with overlapping keywords.

**What happens if a run is interrupted partway through?**
Progress is persisted as the run proceeds, including the keyword/domain cursor and the set of emails already found. Restarting continues from that cursor rather than repeating completed work, which avoids both wasted time and duplicate charges.

**Does the `location` filter make results more accurate?**
It makes them narrower. The location term is appended to every query, so only campaigns whose indexed text mentions that place will match. That improves geographic precision but reduces volume, sometimes sharply. Leave it empty for maximum coverage.

**How should I choose keywords for the best results?**
Use specific two- or three-word phrases that would plausibly appear in the campaigns you want — a cause, a situation, or an organisation type. Start with three to five, measure results per keyword after the run, and replace the terms that underperform.

**Is scraping GoFundMe emails legal?**
The Actor collects only publicly available information. How you use that data is a separate question governed by privacy law and anti-spam regulation in your jurisdiction — the GDPR, the UK Data Protection Act, CAN-SPAM, CASL and similar frameworks. Establish a lawful basis before contacting anyone and honour opt-out requests immediately.

**Can I use this data for cold email marketing?**
Only where the applicable law allows it. Many jurisdictions require prior consent or a demonstrable legitimate interest for unsolicited commercial email to individuals, along with clear sender identification and a working unsubscribe mechanism. Take your own legal advice before running an outreach campaign on harvested addresses.

**What export formats are available?**
The dataset can be exported as JSON, CSV, Excel, XML or RSS from the Apify console, or retrieved through the API. Because the output is entirely flat, CSV imports cleanly into spreadsheets and CRM tools without any transformation.

**Can I run the GoFundMe Email Scraper on a schedule?**
Yes. Apify's scheduler can run any saved input on a recurring basis. Because the public index changes over time, a scheduled run with a stable keyword set will surface newly indexed campaigns that a one-off run would have missed.

**Are the extracted email addresses verified as deliverable?**
No. The scraper reports addresses exactly as they appear in the public text. Some will be stale, role-based, or mistyped by whoever published them. Run the list through an email verification service before any send to protect your sender reputation.

**How do I keep the cost of a run predictable?**
Set `maxEmails` explicitly on every run — it caps unique results and therefore the number of billable rows. Combine it with a tested keyword set so that the results you pay for are ones you can actually use, and start any new configuration with a small ceiling.

***

### 🆘 Support & Feedback

If something is not working as described — an input combination that returns nothing, malformed output rows, or a run that ends unexpectedly — please open a report in the **Issues** tab of this Actor. Include the exact input JSON you used so the behaviour can be reproduced.

Need something custom? A different source network, additional output fields, built-in email verification, or a direct integration with your CRM — write to **scraperhubapi@gmail.com** and describe the requirement.

If the GoFundMe Email Scraper is useful to you, a review on the Actor page genuinely helps, and specific feedback about what you needed and did not get is what drives the next improvements.

***

### ⚖️ Disclaimer

This GoFundMe Email Scraper collects only publicly available information from public search results — the same content any person could see by running the same searches manually. It does not bypass authentication, access private accounts, or retrieve anything hidden behind a login.

Email addresses are personal data. If you process results from this Actor for individuals in the EU, UK or other regulated jurisdictions, you are the data controller: you must establish a lawful basis under the GDPR or the equivalent local framework, provide the required transparency information, honour access and erasure requests, and delete data once your stated purpose has been served. Unsolicited commercial email is separately regulated under regimes including CAN-SPAM, CASL and the ePrivacy rules, and compliance with those is your responsibility.

Use of this Actor is also subject to the terms of service of GoFundMe and of the search infrastructure involved. Review those terms and take your own legal advice before conducting large-scale or commercial collection. Nothing here constitutes legal advice.

If you believe personal data relating to you has been collected through this Actor and you would like it removed, contact **scraperhubapi@gmail.com** with the details and the request will be handled promptly.

# 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
}
```

# Actor output Schema

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

Records scraped by Gofundme Email Scraper Fast Advanced And Cheapest, 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": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/gofundme-email-scraper-fast-advanced-and-cheapest"
        }
    }
}

```

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/fUO9o7vZOvy9rPrV3/builds/upiXx8lGQX22KrdxQ/openapi.json