# Indiegogo Scraper — Creator Leads, Contacts & Launch Monitor (`scrapersdelight/indiegogo-scraper`) Actor

Scrape Indiegogo campaigns and their creators — funding, backers, category, plus the creator's own website and social links — as real B2B leads. Search by category or tag, or monitor new launches on a schedule.

- **URL**: https://apify.com/scrapersdelight/indiegogo-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 per campaign scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Indiegogo Scraper — Creator Leads, Contacts & Launch Monitor

Most Indiegogo scrapers hand you **project stats**. This one hands you **leads.**

For every campaign it also profiles the **creator** — their own **website/store** and **social profiles** — so you get a real B2B contact you can sell to, enrich, or add to a CRM. Search the catalog by category or tag, or run it on a schedule to catch **new launches** the day they go live.

Built for founders, agencies, suppliers, and GTM teams who sell **to the people running crowdfunding campaigns** — fulfilment, manufacturing, marketing, pre-order / where's-my-order tooling, packaging, financing.

Pairs with the [Kickstarter Scraper](https://apify.com/scrapersdelight/kickstarter-scraper) sibling (identical output schema) to cover both platforms.

---

### Why this one

| | Typical Indiegogo scraper | **This actor** |
|---|---|---|
| Campaign stats (funding, backers, category, dates) | ✅ | ✅ |
| Creator's **own website / store** | ❌ | ✅ |
| Creator **social profiles** (FB, X, YouTube, Instagram…) | ❌ | ✅ |
| **New-launch monitor** (schedule it, get only new) | rare | ✅ |
| Full-catalog sweep (auto-tiles the 10k-per-query cap) | ❌ | ✅ |

The website column is the point: pipe it into an email finder (see [Turn leads into email](#turn-leads-into-email)) for a complete outbound list — campaign, creator, site, socials, email.

### What you get (one row per campaign)

- **Campaign** — name, blurb, url, phase (crowdfunding / prelaunch / ended), category, tags
- **Funding** — goal, raised, USD raised, % funded, backers, followers, funded-in-seconds, currency, start / end dates
- **Creator lead** — name, profile url, creator id, platform (indiegogo / gamefound), location
- **Contact** — `website` + `websites_all[]`, `website_source`, and `socials { facebook, twitter_x, youtube, instagram, tiktok, linkedin, pinterest, … }`

#### Coverage notes (honest)

- The creator's own website comes from their Indiegogo profile's `socialMediaUrls` (type "website"). Not every creator lists one — `website_source` is `profile` when found, `none` when not. You only pay `creator-enriched` when a contact is actually found.
- **Gamefound creators:** Indiegogo merged with Gamefound, so many tabletop/game creators now live on `gamefound.com` and have no Indiegogo profile page. Those rows come through with full campaign data and `creator_platform: "gamefound"`, but are **not** enriched in this version (a separate Gamefound source is on the roadmap). Filter on `creator_platform` if you only want enrichable Indiegogo creators.

### Modes

- **Search** *(default)* — campaigns matching a category and/or tag filter.
- **Sweep** — the whole catalog: a broad pass plus per-category tiling to work around Indiegogo's 10,000-results-per-query cap.
- **Monitor** — only campaigns that are **new since the last run**. Point a daily schedule at it for a fresh-launch feed. Optional webhook (Slack/Zapier).

### Turn leads into email

This actor gives you the creator's **website**; pair it with an email finder to complete the contact:

1. Run this actor, export the dataset.
2. Feed the `website` column into **[Local Business Contact Enricher](https://apify.com/scrapersdelight/local-business-enricher)** ($0.01/contact).
3. You now have campaign → creator → website → **email**.

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `campaign-scraped` | **$0.0008** | per campaign row returned |
| `creator-enriched` | **$0.004** | per unique creator **only when a website or social is found** — misses free |
| `new-campaign-detected` | **$0.02** | per new campaign in monitor mode (replaces `campaign-scraped`) |
| `monitor-run-completed` | **$0.05** | per scheduled monitor run |
| `alert-delivered` | **$0.005** | only when a webhook alert is delivered |

**Example** — 10,000 campaigns with enrichment, ~5,000 unique enrichable creators with a contact: `10,000 × $0.0008` + `5,000 × $0.004` ≈ **$28**. Metadata-only (enrichment off) is just `$0.0008`/row.

### Example input

```json
{ "mode": "search", "category": "Camera Gear", "maxItems": 200, "enrichCreators": true }
````

Daily new-launch monitor:

```json
{ "mode": "monitor", "category": "Tabletop Games", "enrichCreators": true, "webhookUrl": "https://hooks.slack.com/services/…" }
```

### FAQ

**Is this only public data?** Yes — public campaign and creator-profile pages via Indiegogo's open API. No login, no private data. You are responsible for compliant outreach (CAN-SPAM / GDPR / CCPA).

**Do I need proxies?** Campaign discovery works on any proxy, but **creator enrichment needs residential** — Indiegogo Cloudflare-gates the creator profile pages and blocks most shared/datacenter IPs. The actor auto-rotates fresh residential IPs and caches good ones (residential is the default). For maximum enrichment yield, plug in your own premium residential proxy and lower `enrichTries`.

**Why are some campaigns not enriched?** Either the creator lists no website/socials, or they're a Gamefound creator (see [Coverage notes](#coverage-notes-honest)).

***

*Public campaign data. Not affiliated with Indiegogo, Inc.*

# Actor input Schema

## `mode` (type: `string`):

search = campaigns matching a category/tag filter. sweep = the whole catalog (auto-tiles categories to beat the 10k-per-query cap). monitor = only NEW campaigns since the last run (schedule it).

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

Filter by an Indiegogo category — a name ('Tabletop Games', 'Camera Gear', 'Health & Fitness') or the exact catalog enum ('CameraGear'). Leave blank for all categories.

## `tags` (type: `array`):

Filter by Indiegogo tag IDs (numeric). Advanced — tag IDs appear in each campaign's tag links.

## `maxItems` (type: `integer`):

Cap on campaigns per run. Set 0 for no cap (sweep). Creator enrichment adds one page fetch per unique creator.

## `enrichCreators` (type: `boolean`):

Fetch each creator's Indiegogo profile to pull their own website + social profiles (the lead data). Costs nothing until a contact is found. Turn OFF for a fast metadata-only pull.

## `monitorStateStore` (type: `string`):

Named key-value store used to remember which campaigns were already seen, so monitor mode only returns NEW ones. Reuse the same name across scheduled runs.

## `webhookUrl` (type: `string`):

In monitor mode, POST newly-detected campaigns to this URL (Slack/Zapier/your endpoint). Leave blank for none.

## `concurrency` (type: `integer`):

How many creator profiles to enrich in parallel.

## `enrichTries` (type: `integer`):

Max fresh-IP attempts per creator page. Indiegogo Cloudflare-gates creator pages and blocks most shared residential IPs, so the actor rotates IPs until one gets through (good IPs are then cached). Premium residential proxies need far fewer.

## `proxyConfiguration` (type: `object`):

The search API works on any proxy, but creator-page enrichment needs residential (Indiegogo Cloudflare-gates those pages). Residential is the default; plug in your own premium residential for max yield.

## `diagnose` (type: `boolean`):

Dev only. Logs per-creator enrichment fetch details.

## Actor input object example

```json
{
  "mode": "search",
  "tags": [],
  "maxItems": 12,
  "enrichCreators": true,
  "monitorStateStore": "indiegogo-monitor-state",
  "concurrency": 5,
  "enrichTries": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "diagnose": false
}
```

# Actor output Schema

## `leads` (type: `string`):

The dataset of campaigns + creators (one item per campaign).

# 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 = {
    "mode": "search",
    "maxItems": 12,
    "enrichCreators": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/indiegogo-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 = {
    "mode": "search",
    "maxItems": 12,
    "enrichCreators": False,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/indiegogo-scraper").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 '{
  "mode": "search",
  "maxItems": 12,
  "enrichCreators": false
}' |
apify call scrapersdelight/indiegogo-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapersdelight/indiegogo-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indiegogo Scraper — Creator Leads, Contacts & Launch Monitor",
        "description": "Scrape Indiegogo campaigns and their creators — funding, backers, category, plus the creator's own website and social links — as real B2B leads. Search by category or tag, or monitor new launches on a schedule.",
        "version": "0.1",
        "x-build-id": "e1hcCdda8eAg4YcwP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~indiegogo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-indiegogo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapersdelight~indiegogo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-indiegogo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapersdelight~indiegogo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-indiegogo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "sweep",
                            "monitor"
                        ],
                        "type": "string",
                        "description": "search = campaigns matching a category/tag filter. sweep = the whole catalog (auto-tiles categories to beat the 10k-per-query cap). monitor = only NEW campaigns since the last run (schedule it).",
                        "default": "search"
                    },
                    "category": {
                        "title": "Category (optional)",
                        "type": "string",
                        "description": "Filter by an Indiegogo category — a name ('Tabletop Games', 'Camera Gear', 'Health & Fitness') or the exact catalog enum ('CameraGear'). Leave blank for all categories."
                    },
                    "tags": {
                        "title": "Tag IDs (optional)",
                        "type": "array",
                        "description": "Filter by Indiegogo tag IDs (numeric). Advanced — tag IDs appear in each campaign's tag links.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max campaigns",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on campaigns per run. Set 0 for no cap (sweep). Creator enrichment adds one page fetch per unique creator.",
                        "default": 100
                    },
                    "enrichCreators": {
                        "title": "Enrich creators (website + socials)",
                        "type": "boolean",
                        "description": "Fetch each creator's Indiegogo profile to pull their own website + social profiles (the lead data). Costs nothing until a contact is found. Turn OFF for a fast metadata-only pull.",
                        "default": true
                    },
                    "monitorStateStore": {
                        "title": "Monitor state store (mode = monitor)",
                        "type": "string",
                        "description": "Named key-value store used to remember which campaigns were already seen, so monitor mode only returns NEW ones. Reuse the same name across scheduled runs.",
                        "default": "indiegogo-monitor-state"
                    },
                    "webhookUrl": {
                        "title": "Alert webhook (optional)",
                        "type": "string",
                        "description": "In monitor mode, POST newly-detected campaigns to this URL (Slack/Zapier/your endpoint). Leave blank for none."
                    },
                    "concurrency": {
                        "title": "Concurrency",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many creator profiles to enrich in parallel.",
                        "default": 5
                    },
                    "enrichTries": {
                        "title": "Enrichment fetch retries",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Max fresh-IP attempts per creator page. Indiegogo Cloudflare-gates creator pages and blocks most shared residential IPs, so the actor rotates IPs until one gets through (good IPs are then cached). Premium residential proxies need far fewer.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "The search API works on any proxy, but creator-page enrichment needs residential (Indiegogo Cloudflare-gates those pages). Residential is the default; plug in your own premium residential for max yield.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Logs per-creator enrichment fetch details.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```