Indiegogo Scraper: 31 Data Fields, Up to 1,000 Free Results/Month

Each record carries 31 fields, including campaign goal, funds gathered, backer count, currency code, and full project story text when fetched directly by URL or campaign slug. On Apify's free plan, 1,000 results cost $5.00, making it easy to extract current campaign stats across tech, creative, community, and gaming categories without maintaining custom browser automation. The Actor works directly from datacenter IPs via TLS impersonation using curl_cffi Chrome 131 and automatically escalates to Apify Proxy on the second block. This tool is built for product researchers, campaign managers, and data analysts tracking crowdfunding performance. It is not for teams that require automated scraping of comments or backer update threads, which are rendered client-side via XHR and not included in dataset records.

Try it before you read further. Apify's free plan includes $5.00 of usage every month with no credit card, enough for up to 1,000 results at $0.005 each before platform usage. Open Indiegogo Scraper on Apify and run the prefilled example.

How reliable is Indiegogo Scraper in production?

Across the last 30 days of public runs on the Apify platform, Indiegogo Scraper recorded 306 runs with the following outcomes.

In the last 30 days, about 2 in a hundred runs failed or timed out. When scheduling unattended runs, build your workflow to handle these occasional failures by implementing automatic retries. Monitoring runs using alerting tools helps catch any unhandled API blocks early.

What does it cost to run Indiegogo Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

Worked example: collecting 10,000 results costs $50.00 in result charges before run-start fees and platform usage. With 1.6% of runs failing or timing out in the last 30 days, budget for re-running a portion of those batches rather than assuming every run completes.

Result charges scale strictly with dataset items, so maxItems is the primary input control governing total cost. Running search or discovery modes with a high cap drives costs, whereas detail-focused modes using a small, targeted list of URLs remain highly predictable. To inspect output quality before spending, run a test with maxItems capped at 10.

How do you run Indiegogo Scraper from the API?

The schema marks 1 of its 15 controls as required: mode. Nothing in the payload below is illustrative. Those are the schema's prefilled defaults for Indiegogo Scraper, so the request works once your token is in place.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~indiegogo-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"discoverTrending","maxItems":10}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "discoverTrending",
  "maxItems": 10
}

run = client.actor("crawlerbros~indiegogo-scraper").call(run_input=run_input)

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

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "discoverTrending",
  "maxItems": 10
}

const run = await client.actor('crawlerbros~indiegogo-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

Because the call is synchronous, your client waits for the whole run. Keep it for exploration. For scheduled work, start the run without waiting and collect the dataset afterwards, so network trouble costs you a retry rather than the results.

Which Indiegogo Scraper inputs matter, and which can you skip?

The mode parameter dictates how data is fetched, requiring query when set to searchCampaigns, or category when using discoverCategory. Filtering controls like minRaised, minBackers, and fundedOnly narrow down the items written to the dataset. For initial runs, keep projectType set to campaign and leave optional filters unset to avoid empty outputs.

• mode (string): What to scrape. Default: "discoverTrending".
• maxItems (integer): Hard cap on emitted records. Indiegogo serves 12-24 results per discovery page; the actor paginates as needed. Default: 50.
• query (string): Free-text keyword search. Required for mode=searchCampaigns.
• category (string): Indiegogo top-level catalog category. Required for mode=discoverCategory; optional otherwise to filter by topic. Provide subCategory for a narrower filter (e.g., film, audio). Default: "tech".
• subCategory (string): Specific Indiegogo sub-category. If set, takes precedence over category (it's narrower).
• sortBy (string): Sort order for search and category browse.
• projectType (string): Filter by project type. Indiegogo lists active crowdfunding campaigns plus marketplace post-campaign products. Default: "campaign".
• status (string): Filter by campaign lifecycle phase.
• slugs (array): Indiegogo campaign URL slugs (the part after /projects/, e.g. witchcraft-the-lanterne-of-light). Default: [].
• urls (array): Full Indiegogo campaign URLs (e.g. https://www.indiegogo.com/projects/<slug>). Default: [].
• minBackers (integer): Drop campaigns with fewer backers than this.
• minRaised (integer): Drop campaigns that raised less than this (in the campaign's native currency).

The other 3 controls, with their defaults, are listed in the input schema on Indiegogo Scraper on Apify.

Fixed-choice controls: mode accepts discoverTrending (Trending campaigns (popular right now)), discoverEndingSoon (Ending soon (campaigns about to close)), discoverNewest (Newest campaigns), discoverMostFunded (Most funded (highest raised amount)), discoverCategory (By category (browse a category)), searchCampaigns (by keyword), byCampaign (By campaign slug (one or more campaigns)), byUrl (full Indiegogo campaign URLs); category accepts tech (Tech & Innovation), creative (Creative Works), community (Community Projects), gaming (Gaming Culture); subCategory accepts 30 values, including productivity (Tech), travel-and-outdoors (Travel & Outdoors (Tech)), home (Tech), energy-and-green-tech (Energy & Green Tech); sortBy accepts trending, newest (Newest first), ending_soon (Ending soon), most_funded (Most funded); projectType accepts any, campaign (Crowdfunding campaigns only), marketplace (Marketplace products only); status accepts any, live (currently raising), ended (campaign closed), in_demand (post-campaign sales).

What does Indiegogo Scraper return?

Output records supply structured campaign metrics including campaignGoal, fundsGathered, backersCount, creator details, and published dates. Detail requests also output storyText and tabUrls for external reference. The records explicitly omit full reward tier breakdowns and client-side loaded comments or updates.

• platform (e.g. indiegogo)
• id (e.g. 244299)
• slug (e.g. Witchcraft-The-Lanterne-of-Light)
• name (e.g. Witchcraft: The Lanterne of Light)
• shortDescription
• url (e.g. https://www.indiegogo.com/en/projects/andrewp...)
• imageUrl
• campaignGoal (e.g. 5000)
• fundsGathered (e.g. 14230)
• backersCount (e.g. 16)
• followersCount (e.g. 54)
• currencySymbol (e.g. $)
• currencyCode (e.g. USD)
• campaignStart (e.g. 2026-05-01T14:00:00Z)
• campaignEnd (e.g. 2026-06-16T13:00:00Z)
• publishedDate (e.g. 2026-04-24T03:55:18.137Z)
• campaignDay (e.g. 8)
• fundedAt (e.g. 2026-05-01T21:10:46.083Z)
• phase (e.g. 10)
• phaseLabel (e.g. live)
• categoryId (e.g. 56)
• categoryName (e.g. Film)
• tags
• creator
• creatorName (e.g. Andrew Pierson)
• creatorUrlName (e.g. andrewpierson-37875854)
• stretchGoals
• tabUrls
• storyHtml
• storyText
• scrapedAt (e.g. 2026-05-09T20:51:08.123456+00:00)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Indiegogo Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Select discoverTrending mode and set category to tech to verify immediate connectivity with the discovery feeds.
2. Limit the run footprint by setting maxItems to 10 for your initial test cycle.
3. Inspect the resulting dataset to confirm fields like campaignGoal and fundsGathered populate as expected.
4. Switch mode to searchCampaigns and input your specific keywords in the query field to locate relevant product niches.
5. Configure projectType to campaign to exclude post-campaign marketplace listings from the results.
6. Change mode to byUrl and populate urls with a single valid campaign URL to fetch detail-only elements.
7. Verify that storyHtml and storyText populate inside the detail output records before scaling up your input lists.
8. Record the returned tabUrls to map targets for comments and updates if your downstream pipelines require manual review.

How do you apply it? Three worked playbooks

These are Indiegogo Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Competitor campaign tracking

Outcome: Track competitor crowdfunding campaigns in your niche

Configure: Set mode to "searchCampaigns", query to "smart home", status to "live", and maxItems to 50.

Working method: Execute the search query daily to monitor competitor activity. Save each run's results and compute daily deltas on fundsGathered and backersCount to evaluate growth velocity.

Deliverable: A structured daily snapshot dataset showing funding growth, backer counts, and campaign status changes.

Stop condition: Stop if the query returns zero results over three consecutive scheduled runs.

Use case 2: Category leaderboards

Outcome: Build leaderboards of the most-funded campaigns by category

Configure: Set mode to "discoverCategory", category to "tech", subCategory to "audio", sortBy to "most_funded", and maxItems to 100.

Working method: Run the extraction across each target category sorted by funding totals. Filter out duplicate project IDs and sort the combined dataset across native currencies.

Deliverable: A aggregate category leaderboard listing top-performing projects, total funds gathered, and backer engagement.

Stop condition: Stop if categorical page requests fail repeatedly or return empty datasets.

Use case 3: Crowdfunding analytics

Outcome: Power crowdfunding analytics dashboards

Configure: Set mode to "discoverTrending", maxItems to 200, autoEscalateOnBlock to true, and projectType to "campaign".

Working method: Perform periodic runs to extract broad datasets across trending campaigns. Pipe the resulting dataset into an external analytics pipeline or database.

Deliverable: A clean pipeline payload supplying current trending campaigns, funding ratios, and duration metrics.

Stop condition: Stop if platform HTTP responses return unhandled errors or rate-limiting escalations fail.

What breaks, and how do you design around it?

• Updates / comments are not extracted (XHR-rendered, no SSR data; see FAQ above).
• Campaign rewards are summarised on the detail page but not paginated separately - the actor returns whatever is in the SSR.
• Currency conversion is not performed - fundsGathered is in the campaign's native currency.
• Cloudflare blocks are auto-escalated to Apify Proxy; if RESIDENTIAL is also blocked the run will surface a typed error record per failed URL.

When campaign updates or comments are needed, use the provided tabUrls to direct a specialized web browser workflow to those endpoints. If your analysis spans multiple countries, normalize fundsGathered using external exchange rates against the authoritative currencyCode field. If Cloudflare blocks occur, ensure autoEscalateOnBlock remains enabled so proxy escalation resolves the request.

When should you not use Indiegogo Scraper?

Do not use this Actor if you require data from open-source hardware projects or Kickstarter campaigns instead of Indiegogo. For hardware-centric crowdfunding, use Crowd Supply Scraper which targets electronics campaigns directly. If your research centers on Kickstarter project details, switch to Kickstarter Project Scraper to leverage native search APIs. This Actor should also be avoided if you need complete backer email lists or full comment threads, as neither is available in the rendered page output.

What should you check before trusting the output?

• Confirm that currencyCode is always present to differentiate campaigns using overlapping currency symbols.
• Check that fundsGathered meets or exceeds your minRaised threshold when that filter is set.
• Verify that storyText is not null when the run utilizes byUrl or byCampaign modes.
• Halt downstream integrations if essential identifiers like id or slug return empty or null values.
• Monitor dataset record counts to ensure that over-restrictive filter configurations have not completely stripped your result set.

None of this proves a record is correct. It gives a scheduled Indiegogo Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

How much does running this scraper cost?

Results cost $0.005 per item, which equals $5.00 per 1,000 results on Apify's free plan. A first test run using the example input caps maxItems at 10, costing at most $0.05 in result charges.

What is the historical success rate for this Actor?

Over the last 30 days, 301 of 306 public runs succeeded, giving a 98.4% success rate. Only 5 runs failed, and zero runs timed out or were aborted by users.

Can I extract campaign comments and updates?

No, comments and updates are loaded via XHR after initial page load and are not scraped. The dataset includes tabUrls for comments and updates so you can access those URLs directly.

How does the scraper handle Cloudflare blocks?

The Actor works directly from datacenter IPs via TLS impersonation (curl_cffi Chrome 131). If Indiegogo's Cloudflare blocks your run, the actor automatically escalates to Apify Proxy (RESIDENTIAL on second block).

How are amounts in different currencies reported?

The fundsGathered and campaignGoal fields reflect the campaign's native currency. The currencyCode is the authoritative ISO code, which is useful when the currencySymbol overlaps with other currencies.

Where to go next

When you are ready to run it, open Indiegogo Scraper on Apify; the free plan covers up to 1,000 results a month.

Other Actors we maintain for related data:

• Crowd Supply Scraper: Scrape Crowd Supply (crowdsupply.com) - a crowdfunding platform focused on open-source hardware and electronics.
• Kickstarter Project Scraper: Extract crowdfunding project data from Kickstarter like name, blurb, goal, pledged amount, backers, deadline, creator, category, country, and more.
• Grants.gov Opportunities Scraper: Scrape federal grant opportunities from Grants.gov - search by keyword, agency, status, category, and funding type.
• GoFundMe Campaign Scraper: Scrape GoFundMe fundraising campaigns - search by keyword, category, country, and funding metrics, or look up campaigns directly by URL.

Related guides:

• Kickstarter Project Scraper: Up to 1,000 Free Results a Month (2026)
• Crunchbase News Scraper: Data Extraction and Integration Guide

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-09-24.

• Actor last updated by its maintainers on 2026-05-22.

• Run outcome figures cover the 30 day public window ending 2026-09-24.

• Indiegogo Scraper on Apify