# Indiegogo Comments Scraper (`stealth_mode/indiegogo-comments-scraper`) Actor

Scrape comments from Indiegogo crowdfunding campaigns with precision. Capture author details, text content, engagement metrics, threading info, and moderation flags across 17+ fields — perfect for sentiment analysis, community research, and campaign insights.

- **URL**: https://apify.com/stealth\_mode/indiegogo-comments-scraper.md
- **Developed by:** [Stealth mode](https://apify.com/stealth_mode) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Comments Scraper: Extract Campaign Feedback Data

---

### What Is Indiegogo?

Indiegogo is a global crowdfunding platform hosting thousands of active campaigns across technology, creative, and innovative product categories. Campaign comments sections contain valuable community feedback, questions, and sentiment data that reveal backer concerns, product reception, and campaign momentum. Manually reviewing thousands of comments is impractical — the **Indiegogo Comments Scraper** automates this, extracting structured comment data at scale for analysis and research.

---

### Overview

The **Indiegogo Comments Scraper** collects comment threads and individual comments from Indiegogo campaign pages, transforming unstructured text into machine-readable records. It is designed for:

- **Campaign creators** analyzing backer feedback and sentiment
- **Market researchers** studying product reception and community engagement
- **Data analysts** building datasets on crowdfunding trends
- **Sentiment analysis teams** processing large comment volumes

Key strengths include robust thread handling (capturing parent-child comment relationships), moderation metadata, timestamp tracking, and engagement metrics like like counts and pinned comments.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "ignore_url_failures": true,
  "max_items_per_url": 200,
  "urls": [
    "https://www.indiegogo.com/en/projects/rfidresearchgroup/proxmark5/comments"
  ]
}
````

| Field | Description |
|---|---|
| `urls` | Direct links to Indiegogo campaign comment sections (must end with `/comments`) |
| `max_items_per_url` | Maximum comments extracted per URL (e.g., `200` collects up to 200 comments per campaign) |
| `ignore_url_failures` | If `true`, continues scraping if some URLs fail; if `false`, stops on error |

> **Tip:** Indiegogo comment pages load dynamically; the scraper handles pagination automatically to reach your `max_items_per_url` limit.

***

### Output Format

**Sample output**

```json
{
  "author_id": null,
  "author_type": 0,
  "children": [
    {
      "author_i_d": 39735651,
      "author_type": 0,
      "children": null,
      "children_total_count": 0,
      "comment_i_d": 7768859,
      "comment_thread_i_d": 1530563,
      "created_at": "2026-05-31T01:18:05.13Z",
      "edited_at": "2026-05-31T01:26:27.843Z",
      "is_deleted": false,
      "is_hidden": false,
      "is_reported_by_creator": false,
      "likes_count": 0,
      "newer_children_count": 0,
      "new_replies_count": 0,
      "parent_i_d": 7768778,
      "pinned_at": null,
      "text": "I had the same question, wouldn’t want to miss out even though I have a predefcon unit. I think it would be alright to ship the housing after since it probably won’t be ready.",
      "user_comment": null
    },
    {
      "author_i_d": 39735158,
      "author_type": 0,
      "children": null,
      "children_total_count": 0,
      "comment_i_d": 7768946,
      "comment_thread_i_d": 1530563,
      "created_at": "2026-05-31T18:46:17.317Z",
      "edited_at": null,
      "is_deleted": false,
      "is_hidden": false,
      "is_reported_by_creator": false,
      "likes_count": 0,
      "newer_children_count": 0,
      "new_replies_count": 0,
      "parent_i_d": 7768778,
      "pinned_at": null,
      "text": "Taylor said on Discord that it's only post defcon. I assume those that got pre-defcon will still receive it but only later, when everyone else will.",
      "user_comment": null
    }
  ],
  "children_total_count": 2,
  "comment_id": null,
  "comment_thread_id": null,
  "created_at": "2026-05-30T12:18:50.9Z",
  "edited_at": null,
  "is_deleted": false,
  "is_hidden": false,
  "is_reported_by_creator": false,
  "likes_count": 0,
  "newer_children_count": 0,
  "new_replies_count": 0,
  "parent_id": null,
  "pinned_at": null,
  "text": "is the transparent case sent in pre defcon fullfilment?",
  "user_comment": null,
  "from_url": "https://www.indiegogo.com/en/projects/rfidresearchgroup/proxmark5/comments"
}
```

Each scraped comment returns a record with 17 core fields, organized by category:

#### Comment Identification

| Field | Meaning |
|---|---|
| `Comment ID` | Unique identifier for this comment within Indiegogo's system |
| `Comment Thread ID` | Thread identifier; comments with the same thread ID belong to the same conversation |
| `Text` | The actual comment text content written by the author |
| `User Comment` | Flag or additional metadata indicating comment type |

#### Author Information

| Field | Meaning |
|---|---|
| `Author ID` | Unique identifier for the person who posted the comment |
| `Author Type` | Category of author (e.g., backer, creator, team member, verified supporter) |

#### Comment Hierarchy & Threading

| Field | Meaning |
|---|---|
| `Parent ID` | ID of the comment this reply is responding to (null if top-level comment) |
| `Children` | Array of child comment IDs (replies to this comment) |
| `Children Total Count` | Total number of direct replies to this comment |
| `Newer Children Count` | Count of newly added replies since last update |
| `New Replies Count` | Number of fresh replies to track new activity |

#### Timestamps & Activity

| Field | Meaning |
|---|---|
| `Created At` | ISO timestamp when the comment was originally posted |
| `Edited At` | ISO timestamp if the comment was edited; null if never modified |
| `Pinned At` | ISO timestamp if the comment was pinned by creator or moderator; null otherwise |

#### Engagement Metrics

| Field | Meaning |
|---|---|
| `Likes Count` | Number of upvotes or likes the comment has received |

#### Moderation & Status

| Field | Meaning |
|---|---|
| `Is Hidden` | Boolean flag; `true` if comment is hidden from public view (e.g., spam, off-topic) |
| `Is Deleted` | Boolean flag; `true` if comment author or moderator deleted it |
| `Is Reported By Creator` | Boolean flag; `true` if the campaign creator flagged this comment for review |

***

### How to Use

1. **Find campaign comment URLs** — Navigate to any Indiegogo campaign page, scroll to the Comments section, and copy the URL (must include `/comments` path).
2. **Configure inputs** — Paste comment section URLs into the `urls` array. Set `max_items_per_url` based on desired volume (e.g., `200` for detailed analysis of all comments).
3. **Set error handling** — Use `ignore_url_failures: true` for batch processing to prevent interruptions if a campaign URL is inaccessible.
4. **Run the scraper** — Start the actor and monitor progress in the run log.
5. **Export results** — Download as JSON, CSV, or Excel for analysis in Python, R, or spreadsheet tools.

**Best practices:**

- Test with `max_items_per_url: 50` first to verify URL format and response structure.
- For campaigns with thousands of comments, use `max_items_per_url: 200–500` to balance coverage and runtime.
- Parent-child relationships are preserved in `Parent ID` and `Children` fields for conversation analysis.

***

### Use Cases & Business Value

- **Sentiment analysis:** Process text content to gauge backer satisfaction and product feedback
- **Community engagement:** Identify influential commenters (high likes, pinned comments) and key discussion threads
- **Competitive research:** Monitor similar campaigns and understand market reception patterns
- **Customer insights:** Extract feature requests, concerns, and questions directly from the community
- **Academic research:** Study crowdfunding dynamics, backer behavior, and creator-community interaction

The Indiegogo Comments Scraper transforms qualitative feedback into quantitative datasets, enabling data-driven decisions on product development, marketing strategy, and community management.

***

### Conclusion

The **Indiegogo Comments Scraper** is the go-to solution for extracting campaign feedback at scale. With full thread context, moderation metadata, and engagement metrics across 17+ fields, it unlocks insights hidden in thousands of comments. Whether analyzing sentiment, tracking community sentiment, or building crowdfunding research datasets, this scraper delivers clean, actionable data in minutes.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the comments list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## `proxy` (type: `object`):

Select proxies to be used by your scraper.

## Actor input object example

```json
{
  "urls": [
    "https://www.indiegogo.com/en/projects/rfidresearchgroup/proxmark5/comments"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "urls": [
        "https://www.indiegogo.com/en/projects/rfidresearchgroup/proxmark5/comments"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("stealth_mode/indiegogo-comments-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 = {
    "urls": ["https://www.indiegogo.com/en/projects/rfidresearchgroup/proxmark5/comments"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("stealth_mode/indiegogo-comments-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 '{
  "urls": [
    "https://www.indiegogo.com/en/projects/rfidresearchgroup/proxmark5/comments"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call stealth_mode/indiegogo-comments-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indiegogo Comments Scraper",
        "description": "Scrape comments from Indiegogo crowdfunding campaigns with precision. Capture author details, text content, engagement metrics, threading info, and moderation flags across 17+ fields — perfect for sentiment analysis, community research, and campaign insights.",
        "version": "0.0",
        "x-build-id": "0vzEpFoHIUgwhKfCR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/stealth_mode~indiegogo-comments-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-stealth_mode-indiegogo-comments-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/stealth_mode~indiegogo-comments-scraper/runs": {
            "post": {
                "operationId": "runs-sync-stealth_mode-indiegogo-comments-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/stealth_mode~indiegogo-comments-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-stealth_mode-indiegogo-comments-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": {
                    "urls": {
                        "title": "URLs of the comments list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the comments list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your scraper."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
