# Gofundme Search By Keyword (`datacach/gofundme-search-by-keyword`) Actor

Search and scrape GoFundMe fundraising campaigns by keyword, location, and category. Extract campaign data including donations, progress, beneficiary info, and URLs. Perfect for market research and competitive analysis. Pay-per-result pricing.

- **URL**: https://apify.com/datacach/gofundme-search-by-keyword.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Lead generation, Other, Developer tools
- **Stats:** 25 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 fundraisers

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?

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

## GoFundMe Campaign Search Scraper — Extract Fundraising Data by Keyword

Search and extract **GoFundMe campaign data** by keyword, location, and category with the **GoFundMe Campaign Search Scraper**. Access donation amounts, fundraising progress, organizer details, and campaign metrics at scale — no official GoFundMe API required. Ideal for market research, donation analytics, competitive analysis, and fundraising intelligence. **Pay-per-result pricing** — you only pay for the data you receive.

### What Does the GoFundMe Search Scraper Do?

- **Search GoFundMe campaigns** by keyword, location, and category
- **Extract campaign data** including fund names, URLs, donation amounts, goal progress percentages, beneficiary information, organizer details, and campaign images
- **Filter by category** (medical, education, emergency, funeral, business, and more), location, goal progress, and creation date
- **Track donation metrics** including amount raised, amount to goal, goal progress percentage, and total donation count
- **Run multi-keyword searches** for broad market coverage across fundraising causes
- **Pass GoFundMe search URLs directly** — the scraper automatically extracts all filters from the URL, no need to re-enter them
- **Resume previous runs** with `start_page` to skip already-collected pages and avoid duplicate data
- **Control result volume** with configurable limits (multiples of 10, up to 1,000 results per run)
- **Output structured JSON** ready for analysis, CRM integration, or custom data pipelines

### How Does the GoFundMe Scraper Work?

1. **Input**\
   Provide one or more search keywords or GoFundMe search URLs (e.g., `"medical emergency"`, `"cancer treatment"`, or a URL copied from GoFundMe's search page) along with optional filters:
   - Location (city, state, or address)
   - Category (medical, education, emergency, funeral, business, etc.)
   - Close-to-goal filter
   - Creation date range
   - Maximum results (multiples of 10: 10, 20, 30, 50, 100, 200, 500, 1,000)
   - Start page (to resume from where a previous run left off)

2. **Process**\
   For each search term, the scraper:
   - Connects to GoFundMe's search API and performs keyword-based queries
   - Applies location, category, and filter criteria to narrow results
   - Extracts campaign data including donation metrics, beneficiary info, and campaign details
   - Paginates automatically to collect results across multiple pages
   - Deduplicates results and respects the configured result limit

3. **Output**\
   A structured JSON dataset with:
   - **Campaign identification**: URL, fund name, campaign ID, object ID
   - **Organizer information**: username
   - **Beneficiary details**: beneficiary name
   - **Financial data**: amount raised, amount to goal, goal progress %, currency code
   - **Engagement metrics**: total donation count
   - **Visual content**: campaign image URL
   - **Search metadata**: search term used, extraction date and timestamp

### Input Parameters

```json
{
  "search_terms": [
    "medical emergency",
    "cancer treatment",
    "education fund"
  ],
  "location": "Las Vegas, NV",
  "category": "medical",
  "close_to_goal": false,
  "timeout_start": "past_30_days",
  "max_results": 100,
  "start_page": 0
}
```

> **Note:** `max_results` must be a multiple of 10 (e.g., 10, 20, 30, 50, 100, 200, 500, 1000).

#### Parameter Reference

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `search_terms` | array | ✅ | — | Keywords or GoFundMe search URLs to search for |
| `max_results` | integer | ✅ | 100 | Maximum results to collect. Must be a multiple of 10, up to 1,000 |
| `location` | string | No | — | City, state, or address to filter by location |
| `category` | string | No | — | Campaign category filter (see table below) |
| `close_to_goal` | boolean | No | `false` | Only return campaigns within 50% of their goal |
| `timeout_start` | string | No | `all_time` | Filter by campaign creation date (see table below) |
| `start_page` | integer | No | `0` | Page to start from (0-indexed). Use to resume a previous run |

#### Using GoFundMe Search URLs in `search_terms`

Instead of typing a keyword and manually setting filters, you can paste a GoFundMe search URL directly into the `search_terms` array. The scraper automatically extracts the keyword, location, category, and all filters from the URL.

This is especially useful for **resuming a previous run** — just paste the URL from your last search and set `start_page` to the next unscraped page:

```json
{
  "search_terms": [
    "https://www.gofundme.com/s?q=cancer&city=New+York&category=medical&timeout_start=past_30_days"
  ],
  "start_page": 5,
  "max_results": 100
}
```

You can mix plain keywords and URLs in the same array:

```json
{
  "search_terms": [
    "education fund",
    "https://www.gofundme.com/s?q=medical+emergency&city=Los+Angeles"
  ],
  "max_results": 200
}
```

**URL parameters recognized:**

| URL param | Maps to | Example |
|---|---|---|
| `q` | keyword | `?q=cancer+treatment` |
| `city` / `location` | location | `?city=New+York` |
| `category` | category | `?category=medical` |
| `close_to_goal` | close_to_goal | `?close_to_goal=1` |
| `timeout_start` | timeout_start | `?timeout_start=past_7_days` |

> **Note:** If an unrecognized parameter value is found (e.g., an unknown category name), the scraper logs a warning and falls back to the default for that filter rather than failing.

#### Resuming a Previous Run with `start_page`

GoFundMe's search API paginates results in pages of ~48 campaigns each (0-indexed). If you already collected pages 0–4 in a previous run (roughly 240 results), set `start_page: 5` in your next run to pick up exactly where you left off.

```json
{
  "search_terms": ["medical emergency"],
  "start_page": 5,
  "max_results": 200
}
```

> **Note:** `start_page` applies to all search terms in the array. If you are resuming multiple keywords, they should all be at the same page offset, or use separate runs per keyword.

#### Available Categories

| Value | GoFundMe Category |
|---|---|
| `medical` | Medical & Healthcare |
| `education` | Education & Schools |
| `emergency` | Emergency & Crisis |
| `funeral` | Funeral & Memorial |
| `business` | Business & Entrepreneurship |
| `family` | Family & Personal |
| `animals` | Animals & Pets |
| `environment` | Environment & Nature |
| `community` | Community & Non-profit |
| `competition` | Competition & Contests |
| `creative` | Creative & Arts |
| `events` | Events & Celebrations |
| `faith` | Faith & Religion |
| `sports` | Sports & Athletics |
| `travel` | Travel & Adventure |
| `volunteer` | Volunteer & Service |
| `wishes` | Wishes & Dreams |
| `other` | Other |

#### Time Filters (`timeout_start`)

| Value | Description |
|---|---|
| *(omitted)* | All time — no date restriction |
| `past_24_hours` | Campaigns created in the last 24 hours |
| `past_7_days` | Campaigns created in the last 7 days |
| `past_30_days` | Campaigns created in the last 30 days |
| `past_12_months` | Campaigns created in the last 12 months |

### Output Example

```json
[
  {
    "url": "https://www.gofundme.com/f/help-start-a-bmx-journey",
    "fundname": "Help Start a BMX Journey",
    "username": "game space",
    "bene_name": "",
    "balance": 0,
    "amount_to_goal": 200,
    "goal_progress": 0.0,
    "donation_count_full": 0,
    "currencycode": "USD",
    "thumb_img_url": "https://images.gofundme.com/uSTmPtM1A8LBsibMwG6g-6kZicQ=/720x405/https://d2g8igdw686xgo.cloudfront.net/96379989_1762525998401067_r.png",
    "objectID": "96379989",
    "search_term": "game",
    "extraction_date": "2025-12-01",
    "extraction_datetime": "2025-12-01T01:55:50.301745+00:00"
  }
]
```

### How to Use This Scraper

#### In the Apify Console

1. Open the actor and click **Run**
2. Paste your input JSON (see example above)
3. Results appear in the **Dataset** tab as they are collected

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

## Standard keyword search
run = client.actor("your-actor-id").call(run_input={
    "search_terms": ["medical emergency", "cancer treatment"],
    "location": "Las Vegas, NV",
    "category": "medical",
    "close_to_goal": False,
    "timeout_start": "past_30_days",
    "max_results": 100
})

## Resume a previous run from page 5 using a URL
run = client.actor("your-actor-id").call(run_input={
    "search_terms": [
        "https://www.gofundme.com/s?q=medical+emergency&city=Las+Vegas&category=medical"
    ],
    "start_page": 5,
    "max_results": 100
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

#### Node.js

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

// Standard keyword search
const run = await client.actor('your-actor-id').call({
    search_terms: ['medical emergency', 'cancer treatment'],
    location: 'Las Vegas, NV',
    category: 'medical',
    close_to_goal: false,
    timeout_start: 'past_30_days',
    max_results: 100
});

// Resume a previous run from page 5 using a URL
const resumeRun = await client.actor('your-actor-id').call({
    search_terms: [
        'https://www.gofundme.com/s?q=medical+emergency&city=Las+Vegas&category=medical'
    ],
    start_page: 5,
    max_results: 100
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Technical Details

| Feature | Details |
|---|---|
| Data source | GoFundMe public search API |
| Pagination | Automatic — handles all result pages |
| Resume support | `start_page` lets you continue from any page offset |
| Input flexibility | Accepts plain keywords or GoFundMe search URLs |
| Result limits | Multiples of 10, up to 1,000 per search term |
| Location support | Geocodes city/state/address strings to coordinates |
| Deduplication | Unique campaign entries guaranteed per run |
| Output format | Structured JSON with consistent field names and types |
| Metadata | Search term + UTC extraction timestamp per record |

### Use Cases

- **Market Research**: Analyze fundraising trends and campaign performance by category or region
- **Competitive Analysis**: Track campaigns in your niche and benchmark fundraising strategies
- **Campaign Discovery**: Find relevant campaigns for partnerships, sponsorships, or charitable support
- **Donation Analytics**: Study goal achievement rates, donation counts, and progress patterns at scale
- **Location Intelligence**: Identify geographic fundraising trends by city or state
- **Trend Analysis**: Surface emerging causes and trending campaigns in real time
- **Data Integration**: Feed GoFundMe campaign data into analytics dashboards, CRMs, or custom workflows

### Frequently Asked Questions

**Does this scraper require a GoFundMe API key?**\
No. This scraper accesses GoFundMe's public search interface — no official API credentials are needed.

**How many results can I get per search term?**\
Up to 1,000 results per keyword. The `max_results` value must be a multiple of 10.

**Can I search multiple keywords in one run?**\
Yes. Pass an array of keywords in `search_terms` and the actor runs a separate search for each, returning combined deduplicated results.

**Can I pass a GoFundMe URL instead of a keyword?**\
Yes. Any item in `search_terms` that starts with `https://` is treated as a GoFundMe search URL. The scraper extracts all filters (keyword, location, category, date range) directly from the URL. You can mix plain keywords and URLs in the same array.

**How do I resume a previous run without re-fetching data I already have?**\
Set `start_page` to the next unscraped page. Pages are 0-indexed and contain ~48 results each — if you collected 240 results (pages 0–4), set `start_page: 5` in your next run. For best results, combine `start_page` with a GoFundMe search URL so all filters are preserved exactly.

**Is location-based filtering supported?**\
Yes. Provide a city, state, or full address in the `location` field. The scraper geocodes it automatically for accurate geographic filtering.

**What format does the scraper return data in?**\
All results are structured JSON records stored in the Apify Dataset. Each record includes campaign URL, fund name, financial data, donor count, image URL, and extraction metadata.

**Is there an official GoFundMe API I can use instead?**\
GoFundMe does not offer a public campaign search API. This actor is the most capable **GoFundMe API alternative** available, providing structured search and extraction through the Apify platform.

**What is the pricing model?**\
This actor uses pay-per-result pricing — you are only charged for the campaign records actually returned, not for the compute time.

### GoFundMe API Alternative

Looking for a **GoFundMe API** or programmatic access to crowdfunding campaign data? This actor is a powerful **GoFundMe API alternative** — providing structured campaign search results, donation metrics, and campaign metadata through a simple, scalable interface on Apify.

Whether you need a **GoFundMe data API**, **GoFundMe scraping API**, or a **GoFundMe search API integration**, this scraper delivers:

- **Keyword-based campaign search** — no GoFundMe API credentials required
- **RESTful access** via Apify's standard actor API
- **Structured JSON output** compatible with any data pipeline or integration
- **Real-time campaign extraction** with automatic pagination
- **Scalable pay-per-result pricing** on the Apify platform
- **Multi-parameter filtering** by keyword, location, category, and date range

Use this actor to build **GoFundMe API integrations**, power fundraising analytics platforms, or feed crowdfunding data into business intelligence tools — all without waiting for an official GoFundMe public API.

### Support

For questions or issues, contact us through Apify's messaging system or reach out directly via email.

### Credits

Developed and maintained by the DataCach team.

# Actor input Schema

## `search_terms` (type: `array`):

Keywords to search for GoFundMe campaigns. Examples: 'medical emergency', 'cancer treatment', 'education fund', 'disaster relief', 'funeral expenses', 'business startup'. You can enter multiple keywords to search across different campaigns.

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

Filter campaigns by location. Enter a city name (e.g., 'New York', 'Los Angeles'), state, or full address. This helps find local fundraising campaigns and location-specific causes.

## `category` (type: `string`):

Filter campaigns by category. Choose from medical expenses, education, emergency relief, funeral costs, business funding, sports, travel, and more. Leave empty to search all categories.

## `close_to_goal` (type: `boolean`):

Filter to show only campaigns that are close to reaching their fundraising goal (within 50% of goal). Useful for finding campaigns that need urgent support or are near completion.

## `timeout_start` (type: `string`):

Filter campaigns by when they were created. Useful for finding recent campaigns, trending fundraisers, or campaigns started within a specific time period.

## `max_results` (type: `integer`):

Maximum number of campaign results to return. The scraper will collect results until reaching this limit or until no more results are available. Set higher for comprehensive data collection, lower for quick searches. REQUIRED: Must be a multiple of 10 (valid examples: 10, 20, 30, 50, 100, 200, 500, 1000).

## `start_page` (type: `integer`):

Page number to start from (0-indexed). Default is 0 (start from the beginning). To resume a previous run, set this to the next unscraped page. For example, if you already collected results from pages 0–4, set this to 5. When search_terms contains GoFundMe URLs, the URL carries all filter settings and this field controls the starting page.

## Actor input object example

```json
{
  "search_terms": [
    "cancer treatment",
    "medical bills",
    "emergency fund"
  ],
  "location": "Las Vegas, NV",
  "category": "",
  "close_to_goal": false,
  "timeout_start": "all_time",
  "max_results": 100,
  "start_page": 0
}
```

# 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 = {
    "search_terms": [
        "medical",
        "emergency",
        "education"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacach/gofundme-search-by-keyword").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 = { "search_terms": [
        "medical",
        "emergency",
        "education",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("datacach/gofundme-search-by-keyword").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 '{
  "search_terms": [
    "medical",
    "emergency",
    "education"
  ]
}' |
apify call datacach/gofundme-search-by-keyword --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datacach/gofundme-search-by-keyword"
        }
    }
}
```

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/WOMaVnMUhm3nsiara/builds/hGd4EaZ8mmAk62B5I/openapi.json