# Kickstarter Scraper - Projects, Funding & Backers (`s-r/kickstarter-scraper`) Actor

Search Kickstarter and get one row per project: funding goal, amount pledged, percent funded, backer count, deadline, category and creator.

- **URL**: https://apify.com/s-r/kickstarter-scraper.md
- **Developed by:** [SR](https://apify.com/s-r) (community)
- **Categories:** E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Kickstarter Scraper

Crowdfunding projects from Kickstarter as a clean table. Search by term, filter
by state and category, and get one row per project with the funding goal, the
amount pledged, how far past or short of target it is, the backer count, the
deadline and who is running it.

Leave the search term empty to browse rather than search, and use **Sort by**
to get the view you actually want: most funded, most backed, ending soonest, or
newest.

### Money is reported twice, on purpose

Kickstarter runs in many currencies, and this is the detail that quietly ruins
an analysis. `goal` and `pledged` are in **the project's own currency**, which
is why `currency` sits next to them. `pledged_converted` is the same figure
converted, with `converted_currency` naming what it was converted to.

Sort a mixed set on `pledged` and you are comparing euros with yen without
being told. Sort on `pledged_converted` and you are not. Both are here so the
choice is yours and visible.

`percent_funded` is a percentage, not a fraction: a project at 930% raised
nine times its goal. Kickstarter's own payload sends `9.3` for that, which is
easy to read as nine per cent.

`pledged_per_backer` is worked out for you, because average pledge is the first
thing anyone computes from this data and it is null rather than a crash when a
project has no backers yet.

### What you get per project

- `name`, `blurb`, `url`, `state`
- `goal`, `pledged`, `currency`, `pledged_converted`, `converted_currency`
- `percent_funded`, `backers_count`, `pledged_per_backer`
- `category`, `parent_category`, `category_id`
- `creator_name`, `creator_id`
- `country`, `country_name`, `location`
- `created_at`, `launched_at`, `deadline`
- `is_staff_pick`, `is_spotlight`, `photo_url`
- `search`, `search_page`, `position`, `total_hits`

`category_id` is worth keeping. Run once without a category, find the id of the
one you care about on any row, then use **Category id** to narrow every run
after that.

### Run sizes

Projects arrive twelve to a page and the endpoint says when it has run out, so
a run stops on its own rather than walking to a page limit. **Maximum
projects** caps the total and **Maximum pages per term** is the rail on a broad
search.

### Errors

| Code | Meaning |
|---|---|
| `no_results` | The search ran and matched nothing |
| `fetch_failed` | The endpoint could not be read after several attempts |

`no_results` and `fetch_failed` are deliberately different. A term nobody has
launched a project for and a request that was refused look identical if you
only count rows, and only one of them is worth rerunning.

### A note on reliability

Route access here is narrow and can change without warning. If a run suddenly
returns `fetch_failed` across the board where it worked last week, that is what
has happened; it is not a bad search term. Re-run once, and if it persists, say
so rather than working around it.

### Related actors

For launches on the other big platform, use **Product Hunt Launches**. For the
companies behind a project rather than the project itself, look at the LinkedIn
company actors.

# Actor input Schema

## `search` (type: `array`):

One per line. Leave a single empty line to browse without a term.

## `state` (type: `string`):

Only projects in this state. Leave on Any to get every state at once.

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

Result order. Most funded and Most backed are the two that turn a broad search into a leaderboard.

## `categoryId` (type: `integer`):

Optional. Every row carries category\_id, so run once and reuse the number.

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

Return only projects Kickstarter's own staff have picked.

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

Twelve arrive per page.

## `maxPages` (type: `integer`):

How many pages to walk per search term. Twelve projects a page, and a run stops early when the search runs out.

## Actor input object example

```json
{
  "search": [
    "board game",
    "enamel pin"
  ],
  "state": "",
  "sort": "",
  "staffPicksOnly": false,
  "maxItems": 100,
  "maxPages": 10
}
```

# Actor output Schema

## `projects` (type: `string`):

One row per project.

## `summary` (type: `string`):

Projects returned and how many are funded.

## `errors` (type: `string`):

Searches that could not be read.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "search": [
        "board game"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s-r/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 = { "search": ["board game"] }

# Run the Actor and wait for it to finish
run = client.actor("s-r/kickstarter-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "search": [
    "board game"
  ]
}' |
apify call s-r/kickstarter-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,s-r/kickstarter-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ig4W8QFQO4Q74c7ZR/builds/3oSZvRf5y2ZsoHvg1/openapi.json