# Kickstarter Scraper (`memo23/kickstarter-scraper`) Actor

Scrape Kickstarter campaigns — funding, backers, deadlines, reward tiers, creator history, full story, risks, and FAQ answers. Filter by keyword, category, state (live to prelaunch), country, or paste any discover URL. Optional creator contact emails. JSON or CSV out.

- **URL**: https://apify.com/memo23/kickstarter-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 campaign rows

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

## Kickstarter Scraper

<p align="center"><img src="https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/kickstarter-logo.png" alt="Kickstarter Scraper logo" width="140"/></p>

Track live, funded, failed, and prelaunch Kickstarter campaigns at scale — straight from Kickstarter's public discover feed into structured JSON. Each row carries the campaign identity, funding totals, backer counts, lifecycle dates, category, creator, and country; optional enrichment adds full reward tiers, update/comment/FAQ counts, creator history, and even the creator's own website and contact email. Filter by search term, category, state, country, and funding thresholds so you only pay for the campaigns you actually want.

#### How it works

![How Kickstarter Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-kickstarter.png)

#### ✨ Why use this scraper?

- **Pure JSON pipeline** — campaigns come from Kickstarter's own discover feed and embedded project JSON, not brittle CSS selectors. Layout redesigns don't break the dataset.
- **Six lifecycle states** — live, successful, failed, canceled, upcoming (prelaunch), or all. Scout campaigns before they launch or mine years of funded history.
- **Funding filters that save you money** — minimum percent funded, minimum backers, minimum USD pledged, launched-within-N-days. Filtered rows are never charged.
- **Full reward-tier extraction** — tier title, price (native + USD), backers per tier, availability, estimated delivery, shipping type, and included items.
- **Story, risks, and FAQ answers** — opt-in fetch of the complete campaign story (HTML + plain text), the "Risks and challenges" section, and FAQ questions with their answers. No other Kickstarter actor outputs FAQ answers.
- **Creator intelligence** — lifetime launched + backed counts, biography, last login, and the creator's own website(s), with an opt-in contact-email finder for outreach lists.
- **Monitoring-ready** — optional cross-run dedupe remembers pushed project ids, so a scheduled run only delivers newly discovered campaigns.

#### 🎯 Use cases

| Who | What they do with it |
|---|---|
| Product scout / white-label buyer | Filter category + `minPercentFunded: 100` to find proven products; contact creators near fulfilment. |
| Manufacturer / fulfilment provider | Track design and tech campaigns crossing funding goals; pitch production when momentum is proven. |
| Trend hunter / analyst | Weekly digest per category; watch `staffPick` + funding velocity for editorially flagged breakouts. |
| Hardware VC | Deal flow by category and funding velocity; `creatorLaunchedCount ≥ 2` surfaces repeat founders. |
| E-commerce founder | Reverse-engineer competitor pricing ladders from reward tiers in your niche. |
| Crowdfunding agency | Pitch services to live campaigns under 50% funded; the email enrichment builds the outreach list. |
| Backer / collector | Track prelaunch (`upcoming`) pages in favourite categories before campaigns go live. |

#### 📥 Supported inputs

| Input | Example | What happens |
|---|---|---|
| Discover/browse URLs | `https://www.kickstarter.com/discover/advanced?category_id=16&sort=newest` | Filters are parsed straight from the pasted URL (category, state, term, sort, country, location, staff picks) |
| Search terms | `["smart home", "board game"]` | Each term becomes a discover search seed |
| Categories | `["technology", "games"]` | 15 top-level categories (slugs or numeric ids) |
| States | `["live", "upcoming"]` | Each state × category × term combination is crawled |
| Country | `"JP"` | ISO 3166-1 alpha-2, combines with everything above |
| Project URLs | `https://www.kickstarter.com/projects/{creator}/{slug}` | Skips discovery, fetches the page directly (always fully enriched) |

**Not supported:** creator profile URLs, private/draft campaigns, anything behind a Kickstarter login.

#### 🔄 How it works

1. **Build seeds** — one discover query per state × category × term combination, plus your country filter and sort.
2. **Walk the feed** — each seed paginates Kickstarter's public discover JSON (12 campaigns per page, up to ~200 pages per combination). The result shuffle is seed-pinned after page 1, so pagination never skips or repeats campaigns mid-run.
3. **Filter** — funding-threshold and recency filters run before anything is charged.
4. **Enrich (optional)** — one project-page fetch per campaign adds reward tiers, add-on count, update/comment/FAQ counts, tags, creator history, biography, and websites.
5. **Find contacts (optional)** — the email finder scrapes the creator's own website (or discovers it from the creator name) for a contact email.
6. **Push** — one merged row per campaign to the dataset. JSON, CSV, or Excel out.

#### ⚙️ Input parameters

| Field | Type | Default | What it does |
|---|---|---|---|
| `startUrls` | string[] | — | Pasted kickstarter.com URLs — discover/browse URLs and project URLs both work. |
| `queries` | string[] | — | Free-text search terms. |
| `categories` | string[] | — | Top-level category slugs or numeric ids. Empty = all. |
| `projectUrls` | string[] | — | Direct project URLs; always fully enriched. |
| `states` | string[] | `["live"]` | live, successful, failed, canceled, upcoming, all. |
| `sort` | enum | `magic` | magic, popularity, newest, end_date, most_funded, most_backed. |
| `country` | string | — | ISO 3166-1 alpha-2 country code. |
| `staffPicksOnly` | boolean | `false` | Only "Projects We Love" — applied server-side, filtered campaigns are never charged. |
| `locationWoeid` | integer | 0 | City/region filter (Yahoo WOEID, e.g. 44418 = London) — Kickstarter's own location filter. |
| `minPercentFunded` | integer | 0 | Floor on funding percent (100 = fully funded only). |
| `minBackers` | integer | 0 | Floor on backer count. |
| `minPledgedUsd` | integer | 0 | Floor on USD pledged. |
| `launchedWithinDays` | integer | 0 | Only campaigns launched in the last N days. |
| `fetchDetails` | boolean | `false` | Reward tiers + counts + creator history per campaign. |
| `fetchStory` | boolean | `false` | Full story HTML + text, "Risks and challenges", FAQ questions **and answers**, environmental commitments. |
| `enrichEmails` | boolean | `false` | Opt-in creator contact-email finder (implies `fetchDetails`). Billed only when a contact is found — $0.005 per found contact, never for misses. |
| `qualifyByPayment` | boolean | `false` | Requires `enrichEmails`. Flags whether the creator's site takes money online (Stripe, Shopify, PayPal, …) — adds `takesPayments`, `paymentProcessors`, `paymentConfidence`. No charge beyond the enrichment. |
| `dedupeAcrossRuns` | boolean | `false` | Skip project ids pushed by previous runs. |
| `maxItems` | integer | 1000 | Hard cap on rows per run. |
| `maxPagesPerSeed` | integer | 200 | Pages of 12 walked per seed combination. |
| `maxConcurrency` | integer | 10 | Parallel HTTP requests. |
| `proxy` | object | Apify residential | Proxy settings for larger runs. |

#### 📊 Output overview

One row per campaign. The canonical core (identity → lifecycle → funding → signals → classification → creator → geo → media → provenance) is always present in the same order, with `null` for anything the source doesn't carry — columns never disappear between rows. Enrichment fields (`rewards`, counts, creator history, contact email) are appended after the core when enabled. `sourceState` / `sourceCategory` / `sourceTerm` / `sourceCountry` record which of your filter combinations produced each row.

#### 📦 Output sample

```json
{
    "type": "campaign",
    "source": "kickstarter",
    "projectId": "452041358",
    "projectKey": "innodigym/omni-x1-best-all-in-one-smart-cable-training-machine",
    "slug": "omni-x1-best-all-in-one-smart-cable-training-machine",
    "url": "https://www.kickstarter.com/projects/innodigym/omni-x1-best-all-in-one-smart-cable-training-machine",
    "name": "OMNI X1: Beyond Real Strength All-in-One Smart Gym Machine",
    "blurb": "Feels Like the Gym, Trains Beyond It. A precision-engineered all-in-one system with smart assist to master every rep at home.",
    "state": "live",
    "createdAt": "2025-12-14T16:54:34.000Z",
    "launchedAt": "2026-06-23T15:00:30.000Z",
    "deadline": "2026-08-07T15:00:30.000Z",
    "daysLeft": 28,
    "currency": "HKD",
    "pledged": 14162387,
    "goal": 78392,
    "usdPledged": 1806639.2,
    "percentFunded": 18066.11,
    "backers": 717,
    "spotlight": false,
    "staffPick": true,
    "category": "Hardware",
    "categorySlug": "technology/hardware",
    "parentCategory": "Technology",
    "creatorId": "683568596",
    "creatorName": "INNODIGYM",
    "creatorUrl": "https://www.kickstarter.com/profile/innodigym",
    "country": "HK",
    "countryName": "Hong Kong",
    "location": "Hong Kong, Hong Kong",
    "photo": "https://i.kickstarter.com/assets/053/677/189/…_original.jpg",
    "sourceState": "live",
    "sourceCategory": "technology",
    "scrapedAt": "2026-07-10T22:30:13.431Z",
    "rewards": [
        {
            "rewardId": 11264106,
            "title": "VIP Offer: OMNI X1 Basic",
            "amount": 12531,
            "amountUsd": 1190,
            "backersCount": 1,
            "available": true,
            "estimatedDelivery": "2026-07-31",
            "shippingType": "anywhere",
            "items": ["OMNI X1 Basic", "Instructions"]
        }
    ],
    "rewardsCount": 11,
    "addOnsCount": 15,
    "updatesCount": 4,
    "commentsCount": 427,
    "faqCount": 17,
    "creatorLaunchedCount": 2,
    "creatorBackedCount": 0,
    "creatorWebsites": ["https://www.innodigym.com"],
    "creatorLastLogin": "2026-07-10T08:16:05.000Z"
}
````

#### 🗂 Key output fields

| Group | Fields |
|---|---|
| Identity | `projectId`, `projectKey` (creator/slug — canonical across reissues), `slug`, `url`, `name`, `blurb` |
| Lifecycle | `state`, `createdAt`, `launchedAt`, `deadline`, `stateChangedAt`, `daysLeft` |
| Funding | `currency`, `pledged`, `goal`, `usdPledged`, `convertedPledgedAmount`, `percentFunded`, `backers` |
| Signals | `spotlight`, `staffPick` (Projects We Love), `prelaunchActivated`, `inPostCampaignPledging` |
| Classification | `category`, `categorySlug`, `parentCategory`, `categoryId` |
| Creator | `creatorId`, `creatorName`, `creatorSlug`, `creatorUrl` |
| Geo | `country`, `countryName`, `location`, `locationCountry`, `locationState` |
| Enrichment (`fetchDetails`) | `rewards[]`, `rewardsCount`, `addOnsCount`, `updatesCount`, `commentsCount`, `faqCount`, `tags[]`, `creatorLaunchedCount`, `creatorBackedCount`, `creatorBiography`, `creatorWebsites[]`, `creatorLastLogin` |
| Story (`fetchStory`) | `story` (HTML), `storyText`, `risks`, `faqs[]` (question + answer), `environmentalCommitments[]` |
| Contacts (`enrichEmails`) | `contactEmail`, `contactWebsite`, `emailEnrichment`; with `qualifyByPayment`: `takesPayments`, `paymentProcessors`, `stripeLiveKey`, `paymentConfidence` |
| Provenance | `sourceState`, `sourceCategory`, `sourceTerm`, `sourceCountry`, `scrapedAt` |

#### ❓ FAQ

**Do I need a Kickstarter account?**
No. The actor only reads the public discover feed and public project pages — nothing behind a login.

**Can I track a campaign's funding over time?**
Yes — run the actor on an Apify schedule with the same filters and store snapshots keyed on `projectId`, then plot `pledged` / `backers` / `percentFunded` over time. Leave `dedupeAcrossRuns` off so rows refresh each run.

**How do I only get newly discovered campaigns on a schedule?**
Turn `dedupeAcrossRuns` on. Pushed project ids are remembered in a named key-value store and skipped on later runs.

**Does it cover prelaunch pages?**
Yes — `states: ["upcoming"]` returns prelaunch campaigns for early scouting. These rows have `launchedAt: null` and no funding totals yet, but carry the creator and category for outreach.

**How reliable is the contact-email finder, and what does it cost?**
Best-effort. When the creator lists their own website on the project page, that site is scraped directly (highest hit rate); otherwise the finder tries to discover the site from the creator name. You're only billed when a contact is actually found — $0.005 per found contact via the "Additional data" event, never for misses. Rows without a findable email simply omit the contact fields at no charge.

**Will Kickstarter block the scraper?**
The discover feed is a public JSON endpoint and tolerates normal volumes. For large runs (thousands of enriched campaigns), keep the default residential proxy setting — Kickstarter throttles datacenter IP ranges past a few hundred fast requests.

**Why do I get fewer rows than `maxItems`?**
Your funding filters run before rows are pushed, and Kickstarter caps each filter combination near 200 pages (~2,400 campaigns). Split a big pull across more categories/states/terms to widen coverage.

#### 💬 Support

- 🐛 Found a bug or need a field added? Open an issue on the actor's **Issues** tab: https://apify.com/memo23/kickstarter-scraper/issues
- 💬 Custom scraping needs (Indiegogo, other crowdfunding platforms, bespoke pipelines)? Message me through the actor page.

#### 🛠 Additional services

- Custom actor development for any directory or listing site
- Managed data delivery: schedules, webhooks, direct-to-warehouse exports
- Merging this dataset with ProductHunt launches, Amazon listings, or Etsy comps

#### 🔎 Explore more scrapers

Check my Apify profile for 250+ actors covering jobs, real estate, reviews, e-commerce, and lead generation: https://apify.com/memo23

***

### 🤖 For AI Agents & LLM Apps

**Purpose:** structured Kickstarter campaign data — funding, backers, dates, reward tiers, creator history, story text, contact emails — from search filters or pasted URLs.

**Minimal tested input:**

```json
{ "categories": ["technology"], "states": ["live"], "minPercentFunded": 100, "maxItems": 25 }
```

Or paste any URL: `{ "startUrls": ["https://www.kickstarter.com/discover/advanced?category_id=16&sort=newest"] }`

**Output fields (flat, one row per campaign):** `projectId, projectKey, name, blurb, url, state, launchedAt, deadline, daysLeft, currency, pledged, goal, usdPledged, percentFunded, backers, spotlight, staffPick, category, parentCategory, creatorId, creatorName, creatorUrl, country, location, photo, videoUrl, scrapedAt` — plus with `fetchDetails: true`: `rewards[], rewardsCount, updatesCount, commentsCount, faqCount, creatorLaunchedCount, creatorBackedCount, creatorWebsites[]`; with `fetchStory: true`: `story, storyText, risks, faqs[]`; with `enrichEmails: true`: `contactEmail, contactWebsite`.

**Billing:** $0.006 per campaign row + $0.005 actor start; `enrichEmails` adds $0.005 per contact actually found (never for misses). Enrichment toggles add requests, not per-row charges.

**Agent-relevant behaviors:** funding filters (`minPercentFunded`, `minBackers`, `minPledgedUsd`, `launchedWithinDays`) drop rows before they're charged. `states: ["upcoming"]` returns prelaunch campaigns with `launchedAt: null`. `dedupeAcrossRuns: true` makes scheduled runs emit only newly discovered campaigns. Rows stream to the dataset as scraped — read partial results any time.

***

### 💰 Pricing

| Event | When charged | Rate |
|---|---|---|
| Campaign row | Each campaign pushed to the dataset | $0.006 |
| Actor start | Once per run, per GB of memory | $0.005 |
| Additional data | Only when a contact email is actually found (`enrichEmails`) | $0.005 per found contact |

Reward tiers, counts, creator history, and story enrichment are included in the campaign-row price — no extra per-row charge.

***

### ⚠️ Disclaimer

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Kickstarter, PBC or any of its subsidiaries or affiliates. All trademarks mentioned are the property of their respective owners.

The scraper accesses only publicly available campaign pages and the public discover feed — no authenticated endpoints, backer-only content, or anything behind a Kickstarter login. Users are responsible for ensuring their use complies with Kickstarter's Terms of Service, applicable data-protection law (GDPR, CCPA, etc.), and any contractual obligations of their own organisation.

***

### SEO Keywords

kickstarter scraper, scrape kickstarter, kickstarter api, kickstarter campaign tracker, kickstarter data export, crowdfunding intelligence, crowdfunding market research, kickstarter trend tracker, kickstarter funding tracker, kickstarter reward tiers data, kickstarter creator contact, crowdfunding deal flow, hardware deal flow, product scouting tool, kickstarter prelaunch tracker, kickstarter category report, kickstarter competitor analysis, kicktraq alternative, kickstarter campaign intelligence, Apify kickstarter actor

# Actor input Schema

## `startUrls` (type: `array`):

Pasted kickstarter.com URLs — both kinds work: discover/browse URLs (e.g. `https://www.kickstarter.com/discover/advanced?category_id=16&sort=newest`, their filters are parsed automatically) and direct project URLs.

## `queries` (type: `array`):

Free-text Kickstarter search terms, e.g. `smart home` or `board game`. Empty means no keyword search.

## `categories` (type: `array`):

Top-level Kickstarter categories. Allowed values: art, comics, crafts, dance, design, fashion, film-and-video, food, games, journalism, music, photography, publishing, technology, theater (numeric Kickstarter category ids also accepted). Empty means all categories.

## `projectUrls` (type: `array`):

Direct kickstarter.com project URLs, e.g. `https://www.kickstarter.com/projects/creator/slug`. Skips discovery and fetches each project page straight away (always fully enriched).

## `states` (type: `array`):

Campaign lifecycle states to include. Allowed values: live, successful, failed, canceled, upcoming (prelaunch pages), all. Default: live.

## `sort` (type: `string`):

Discover sort key. `magic` is Kickstarter's default relevance ranking.

## `country` (type: `string`):

Filter to campaigns based in one country. ISO 3166-1 alpha-2 code, e.g. US, GB, DE, JP. Empty means worldwide.

## `staffPicksOnly` (type: `boolean`):

Only campaigns flagged "Projects We Love" by Kickstarter's editors. Applied server-side, so filtered-out campaigns are never fetched or charged.

## `locationWoeid` (type: `integer`):

City/region-level filter using a Yahoo WOEID — Kickstarter's own location filter (e.g. 44418 = London, 2459115 = New York). Find the id by picking a location on Kickstarter's discover page and copying `woe_id` from the URL. 0 disables.

## `minPercentFunded` (type: `integer`):

Only push campaigns at or above this funding percent. 100 means fully funded only. 0 disables the filter.

## `minBackers` (type: `integer`):

Only push campaigns with at least this many backers. 0 disables the filter.

## `minPledgedUsd` (type: `integer`):

Only push campaigns with at least this much pledged, converted to USD. 0 disables the filter.

## `launchedWithinDays` (type: `integer`):

Only push campaigns launched within this many days. 0 disables the filter.

## `fetchDetails` (type: `boolean`):

Fetch each campaign's project page for full enrichment: reward tiers (title, price, backers per tier, estimated delivery, shipping, included items), add-on count, update/comment/FAQ counts, tags, creator biography, creator websites, and creator history (lifetime launched + backed projects). One extra page fetch per campaign; no extra charge per row. Direct project URLs are always fully enriched.

## `fetchStory` (type: `boolean`):

Fetch the full campaign story via Kickstarter's GraphQL API: complete story HTML and plain text, the "Risks and challenges" section, FAQ questions with answers, and environmental commitments. One extra request per campaign. Heavy fields — turn on only when you need the actual copy.

## `enrichEmails` (type: `boolean`):

Opt-in and best-effort: try to find a contact email for each campaign's creator by scraping the creator's own website (taken from the project page) or discovering it from the creator name. Adds `contactEmail` and `contactWebsite` columns plus a detailed `emailEnrichment` object. Turning this on also enables full campaign details. Billed via the Additional data event only when a contact is actually found ($0.005 per found contact — misses are never charged).

## `qualifyByPayment` (type: `boolean`):

Requires "Enrich with contact emails". Scans each business's website — reusing the pages already fetched for email discovery, so no extra cost or time — for payment processors and e-commerce platforms (Stripe, Shopify, PayPal, Paddle, Lemon Squeezy, WooCommerce, Square, Chargebee and more). Adds takesPayments (is this a real paying business?), paymentProcessors (which stack), stripeLiveKey (the public key if exposed) and paymentConfidence. Turn raw contacts into monetization-qualified leads. No charge beyond the email enrichment it rides on.

## `dedupeAcrossRuns` (type: `boolean`):

Remember pushed project ids in a named key-value store and skip them on later runs. Turn on for scheduled monitoring runs that only want newly discovered campaigns.

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

Hard cap on campaign rows pushed per run.

## `maxPagesPerSeed` (type: `integer`):

Pages of 12 campaigns to walk per state × category × term combination. Kickstarter stops serving results near page 200 per combination.

## `maxConcurrency` (type: `integer`):

Maximum number of pages processed in parallel.

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

Proxy settings. Residential proxy is recommended for larger runs — Kickstarter throttles datacenter ranges past a few hundred fast requests.

## Actor input object example

```json
{
  "queries": [
    "smart home"
  ],
  "categories": [
    "technology"
  ],
  "states": [
    "live"
  ],
  "sort": "magic",
  "staffPicksOnly": false,
  "locationWoeid": 0,
  "minPercentFunded": 0,
  "minBackers": 0,
  "minPledgedUsd": 0,
  "launchedWithinDays": 0,
  "fetchDetails": false,
  "fetchStory": false,
  "enrichEmails": false,
  "qualifyByPayment": false,
  "dedupeAcrossRuns": false,
  "maxItems": 1000,
  "maxPagesPerSeed": 200,
  "maxConcurrency": 10,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "queries": [
        "smart home"
    ],
    "categories": [
        "technology"
    ],
    "states": [
        "live"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/kickstarter-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 = {
    "queries": ["smart home"],
    "categories": ["technology"],
    "states": ["live"],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/kickstarter-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 '{
  "queries": [
    "smart home"
  ],
  "categories": [
    "technology"
  ],
  "states": [
    "live"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call memo23/kickstarter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kickstarter Scraper",
        "description": "Scrape Kickstarter campaigns — funding, backers, deadlines, reward tiers, creator history, full story, risks, and FAQ answers. Filter by keyword, category, state (live to prelaunch), country, or paste any discover URL. Optional creator contact emails. JSON or CSV out.",
        "version": "0.0",
        "x-build-id": "AVBUgcid5ukFqeJpk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/memo23~kickstarter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-memo23-kickstarter-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/memo23~kickstarter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-memo23-kickstarter-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/memo23~kickstarter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-memo23-kickstarter-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": {
                    "startUrls": {
                        "title": "Kickstarter URLs",
                        "type": "array",
                        "description": "Pasted kickstarter.com URLs — both kinds work: discover/browse URLs (e.g. `https://www.kickstarter.com/discover/advanced?category_id=16&sort=newest`, their filters are parsed automatically) and direct project URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "queries": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Free-text Kickstarter search terms, e.g. `smart home` or `board game`. Empty means no keyword search.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Top-level Kickstarter categories. Allowed values: art, comics, crafts, dance, design, fashion, film-and-video, food, games, journalism, music, photography, publishing, technology, theater (numeric Kickstarter category ids also accepted). Empty means all categories.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "projectUrls": {
                        "title": "Project URLs",
                        "type": "array",
                        "description": "Direct kickstarter.com project URLs, e.g. `https://www.kickstarter.com/projects/creator/slug`. Skips discovery and fetches each project page straight away (always fully enriched).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "Campaign states",
                        "type": "array",
                        "description": "Campaign lifecycle states to include. Allowed values: live, successful, failed, canceled, upcoming (prelaunch pages), all. Default: live.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "magic",
                            "popularity",
                            "newest",
                            "end_date",
                            "most_funded",
                            "most_backed"
                        ],
                        "type": "string",
                        "description": "Discover sort key. `magic` is Kickstarter's default relevance ranking.",
                        "default": "magic"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Filter to campaigns based in one country. ISO 3166-1 alpha-2 code, e.g. US, GB, DE, JP. Empty means worldwide."
                    },
                    "staffPicksOnly": {
                        "title": "Projects We Love only",
                        "type": "boolean",
                        "description": "Only campaigns flagged \"Projects We Love\" by Kickstarter's editors. Applied server-side, so filtered-out campaigns are never fetched or charged.",
                        "default": false
                    },
                    "locationWoeid": {
                        "title": "Location (WOEID)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "City/region-level filter using a Yahoo WOEID — Kickstarter's own location filter (e.g. 44418 = London, 2459115 = New York). Find the id by picking a location on Kickstarter's discover page and copying `woe_id` from the URL. 0 disables.",
                        "default": 0
                    },
                    "minPercentFunded": {
                        "title": "Minimum percent funded",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only push campaigns at or above this funding percent. 100 means fully funded only. 0 disables the filter.",
                        "default": 0
                    },
                    "minBackers": {
                        "title": "Minimum backers",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only push campaigns with at least this many backers. 0 disables the filter.",
                        "default": 0
                    },
                    "minPledgedUsd": {
                        "title": "Minimum pledged (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only push campaigns with at least this much pledged, converted to USD. 0 disables the filter.",
                        "default": 0
                    },
                    "launchedWithinDays": {
                        "title": "Launched within last N days",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only push campaigns launched within this many days. 0 disables the filter.",
                        "default": 0
                    },
                    "fetchDetails": {
                        "title": "Fetch full campaign details (reward tiers + creator history)",
                        "type": "boolean",
                        "description": "Fetch each campaign's project page for full enrichment: reward tiers (title, price, backers per tier, estimated delivery, shipping, included items), add-on count, update/comment/FAQ counts, tags, creator biography, creator websites, and creator history (lifetime launched + backed projects). One extra page fetch per campaign; no extra charge per row. Direct project URLs are always fully enriched.",
                        "default": false
                    },
                    "fetchStory": {
                        "title": "Fetch full campaign story (story + risks + FAQ text)",
                        "type": "boolean",
                        "description": "Fetch the full campaign story via Kickstarter's GraphQL API: complete story HTML and plain text, the \"Risks and challenges\" section, FAQ questions with answers, and environmental commitments. One extra request per campaign. Heavy fields — turn on only when you need the actual copy.",
                        "default": false
                    },
                    "enrichEmails": {
                        "title": "Find creator contact emails (experimental)",
                        "type": "boolean",
                        "description": "Opt-in and best-effort: try to find a contact email for each campaign's creator by scraping the creator's own website (taken from the project page) or discovering it from the creator name. Adds `contactEmail` and `contactWebsite` columns plus a detailed `emailEnrichment` object. Turning this on also enables full campaign details. Billed via the Additional data event only when a contact is actually found ($0.005 per found contact — misses are never charged).",
                        "default": false
                    },
                    "qualifyByPayment": {
                        "title": "💳 Qualify by payment (flag businesses that take money online)",
                        "type": "boolean",
                        "description": "Requires \"Enrich with contact emails\". Scans each business's website — reusing the pages already fetched for email discovery, so no extra cost or time — for payment processors and e-commerce platforms (Stripe, Shopify, PayPal, Paddle, Lemon Squeezy, WooCommerce, Square, Chargebee and more). Adds takesPayments (is this a real paying business?), paymentProcessors (which stack), stripeLiveKey (the public key if exposed) and paymentConfidence. Turn raw contacts into monetization-qualified leads. No charge beyond the email enrichment it rides on.",
                        "default": false
                    },
                    "dedupeAcrossRuns": {
                        "title": "Skip campaigns pushed in previous runs",
                        "type": "boolean",
                        "description": "Remember pushed project ids in a named key-value store and skip them on later runs. Turn on for scheduled monitoring runs that only want newly discovered campaigns.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum campaigns to scrape",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Hard cap on campaign rows pushed per run.",
                        "default": 1000
                    },
                    "maxPagesPerSeed": {
                        "title": "Max discover pages per seed",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Pages of 12 campaigns to walk per state × category × term combination. Kickstarter stops serving results near page 200 per combination.",
                        "default": 200
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of pages processed in parallel.",
                        "default": 10
                    },
                    "proxy": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxy is recommended for larger runs — Kickstarter throttles datacenter ranges past a few hundred fast requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
