# Makuake Project Scraper (`research_master/makuake-project-scraper`) Actor

Collect public Makuake projects from Discover, ranking, category, tag, or project URLs with funding metrics, creator/category metadata, deduplication, and collection audits.

- **URL**: https://apify.com/research\_master/makuake-project-scraper.md
- **Developed by:** [Research Master](https://apify.com/research_master) (community)
- **Categories:** Automation, Agents, E-commerce
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $6.90 / 1,000 results

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Makuake Project Scraper

Find and collect structured public Makuake project data for crowdfunding market research, competitor tracking, launch benchmarking, and recurring monitoring.

Use keywords when you want the Actor to discover projects for you. Keep `startUrls` empty, or combine keywords with project, Discover, ranking, category, or tag URLs when you need a controlled seed set.

The Input tab is prefilled with one public project URL so a first test run stays small and finishes quickly. Clear or replace that sample URL before a keyword-only run. The prefill affects only the Console input form; Saved Tasks and API calls keep their supplied inputs and defaults.

### What this Actor does

The Actor uses a two-stage workflow:

1. Discover candidate projects from Makuake keyword searches and optional Start URLs.
2. Merge duplicates, filter and rank listing cards, select the requested Top N, and visit only those project pages for full details.

The default dataset contains one row per successfully collected project. Page and run audits are stored separately in the run's key-value store, so audit records do not become dataset results.

### Keyword search examples

Find up to 100 car-refrigerator-related projects and rank them by the funding amount shown on Makuake listing cards:

```json
{
  "keywords": ["車載冷蔵庫", "ポータブル冷蔵庫"],
  "excludeKeywords": ["マグネット", "ステッカー"],
  "matchMode": "any",
  "keywordMatchScope": "title",
  "status": "all",
  "sortBy": "amount_raised",
  "resultsWanted": 100,
  "candidateLimit": 500,
  "maxPages": 10,
  "includeStory": true
}
```

For broader discovery, set `keywordMatchScope` to `makuake_search`. This keeps projects returned by Makuake even when the literal keyword does not appear in the listing title, but it can also retain more false positives.

#### What "popular" means

Makuake keyword search does not expose a reliable official popularity sort. In this Actor, `sortBy: "amount_raised"` uses the funding amount shown on each discovered listing card as a transparent popularity proxy. It is not an official Makuake popularity score.

`sortBy: "relevance"` preserves Makuake's result/listing order instead. Funding values and order are snapshots from the collection time.

### Start URL examples

`startUrls` is optional and accepts:

- A project URL, such as `https://www.makuake.com/project/example/`
- A Discover URL, such as `https://www.makuake.com/discover/all`
- A ranking URL, such as `https://www.makuake.com/discover/most-funded`
- A category URL, such as `https://www.makuake.com/discover/categories/product/`
- A tag URL, such as `https://www.makuake.com/discover/tags/94`

URL-only run:

```json
{
  "startUrls": [
    { "url": "https://www.makuake.com/discover/categories/product/" }
  ],
  "resultsWanted": 50,
  "maxPages": 10,
  "includeStory": false,
  "includeImages": true
}
```

Mixed keyword and URL run:

```json
{
  "keywords": ["車載冷蔵庫"],
  "startUrls": [
    { "url": "https://www.makuake.com/project/example/" },
    { "url": "https://www.makuake.com/discover/categories/product/" }
  ],
  "sortBy": "amount_raised",
  "resultsWanted": 100
}
```

Direct project URLs are always kept ahead of discovered listing candidates and bypass keyword, exclusion, and status filters. They still count toward the global `resultsWanted` limit. If both keywords and Start URLs are omitted, the Actor falls back to `https://www.makuake.com/discover/all` for backward compatibility.

### Input controls

| Field | Purpose |
| --- | --- |
| `keywords` | Up to 20 unique Makuake search terms or phrases. One search listing is opened per keyword. |
| `excludeKeywords` | Excludes non-direct candidates when any term appears in the listing title. |
| `matchMode` | `any` keeps a candidate matching at least one keyword; `all` requires every keyword. |
| `keywordMatchScope` | `title` uses literal listing-title matching; `makuake_search` trusts membership in Makuake search results. |
| `status` | Keeps all, active, ended, or coming-soon listing candidates. |
| `sortBy` | `amount_raised` ranks by the listing funding snapshot; `relevance` preserves discovery order. |
| `startUrls` | Optional project or public listing URLs. Multiple sources can be combined. |
| `resultsWanted` | Global maximum after source merging, filtering, and ranking. |
| `candidateLimit` | Maximum unique listing candidates retained before filtering and ranking. |
| `maxPages` | Maximum scroll/load-more cycles per listing page. |
| `includeStory` | Adds long project-detail text. Off by default. |
| `includeImages` | Adds project-detail image URLs. On by default. |
| `maxConcurrency` | Parallel browser pages, limited to 1-10. |
| `requestDelayMs` | Polite delay before each page is processed. |
| `proxyConfiguration` | Apify Proxy settings. Cloud requests without a proxy may be blocked. |

`candidateLimit` is automatically raised to at least `resultsWanted`. A run can return fewer than requested when the discovered pool is smaller, candidates fail filters, or project pages fail to load.

### How it compares with Kickstarter scrapers

The input follows the familiar Kickstarter Discover workflow, while adding keyword discovery tailored to Makuake's public search pages.

| Kickstarter scraper pattern | Makuake equivalent in this Actor |
| --- | --- |
| Kickstarter keyword or Discover search | Makuake keyword search plus optional Discover, ranking, category, or tag URLs |
| Project ID or slug deduplication | Stable Makuake project slug deduplication across all sources |
| Goal, pledged, backers, funded percentage | Amount raised in JPY, supporters, achievement rate |
| Creator and category metadata | Makuake creator and category metadata |
| Project deadline and state | Available start/end fields plus normalized active, ended, or coming-soon status |
| Result and page limits | `resultsWanted`, `candidateLimit`, and `maxPages` safety caps |
| Proxy configuration | Apify Proxy configuration; recommended for cloud runs |

Makuake does not expose the same field set or navigation model as Kickstarter. Empty fields mean the public page did not expose a reliable value at collection time; the Actor does not invent missing goals, currencies, locations, or dates.

### Output

| Storage | Record | Meaning |
| --- | --- | --- |
| Default dataset | `project` rows | One structured row per unique successfully collected Makuake project. |
| Key-value store | `PAGE_AUDITS` | Listing/search audit objects with query keyword, links found, new candidates, expansion cycles, and success status. |
| Key-value store | `RUN_AUDIT` | Inputs, candidate/filter/selection totals, exclusions, collection totals, and failures. |

All three outputs are linked from the run's **Output** tab.

Project records can include:

- Project ID, slug, title, description, canonical URL, and main image
- Creator and category names and URLs
- Amount raised in JPY, supporter count, achievement rate, remaining text, and normalized status
- Start/end timestamps when reliably exposed
- Tags, project image URLs, and optional story text
- Matched keywords and all source listing URLs
- Discovery rank, final selection rank, listing funding snapshot, selection sort, and scrape timestamp

### Validation checklist

1. Confirm the `RUN_AUDIT.failures` list is empty or review each failed URL.
2. Compare `unique_projects_discovered`, `projects_after_filters`, `projects_selected`, and `projects_collected`.
3. Check each `PAGE_AUDITS` item for `success: true` and a plausible project count.
4. Keep `matched_keywords`, `source_list_urls`, and `selection_rank` when ranking or sampling matters.
5. Treat amount and supporter values as a snapshot at `scraped_at`, not final campaign results unless the project has ended.

### Limits and responsible use

- Collects public Makuake pages only; it does not log in or access account-specific data.
- Makuake can block cloud datacenter traffic. Apify Proxy is recommended, but no proxy guarantees access.
- Search and listing pages load dynamically, so `maxPages` is a safety cap rather than a guaranteed page count.
- Empty or failed pages are retried once. Final failures include compact page diagnostics in `RUN_AUDIT.failures`.
- Keyword title matching is literal after whitespace and Japanese Unicode normalization; it is not semantic search.
- Listing-card status and amount are used for pre-detail filtering and ranking. The detail-page fields remain the final collected snapshot.
- Long story text and image arrays increase storage and transfer usage.
- Page changes can require parser maintenance; always inspect audit records.
- Use reasonable concurrency and comply with applicable laws, Makuake terms, and your organization's data-handling rules.

# Actor input Schema

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

Optional Makuake project or public listing URLs. You can use URLs alone, keywords alone, or both. Direct project URLs are kept first and count toward the global result limit.

## `keywords` (type: `array`):

Optional Japanese search terms or phrases. The Actor opens one Makuake search listing per unique keyword and merges duplicate projects.

## `excludeKeywords` (type: `array`):

Exclude discovered projects whose listing title contains any of these terms. Direct project URLs bypass this filter.

## `matchMode` (type: `string`):

Require any keyword or every keyword. With title matching, this is evaluated against each listing title.

## `keywordMatchScope` (type: `string`):

Title is stricter and removes many search-result false positives. Makuake search keeps projects returned by Makuake even when the literal keyword is absent from the title.

## `status` (type: `string`):

Filter keyword/listing discoveries using the status shown on the listing card. Direct project URLs bypass this filter.

## `sortBy` (type: `string`):

Amount raised ranks listing cards by their JPY funding snapshot. Relevance preserves Makuake search/listing order. Direct project URLs always come first.

## `resultsWanted` (type: `integer`):

Global maximum after merging and filtering all sources. Direct project URLs count toward this limit.

## `candidateLimit` (type: `integer`):

Maximum unique listing candidates retained before filtering and ranking. It is automatically raised to at least Maximum projects.

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

Maximum scroll or load-more cycles per listing URL. This is a safety cap, not a guaranteed page count.

## `includeStory` (type: `boolean`):

Include the long project-detail text. Disabled by default to keep datasets compact.

## `includeImages` (type: `boolean`):

Include public project-detail image URLs found on each project page.

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

Parallel browser pages. Keep this low to reduce load and blocking risk.

## `requestDelayMs` (type: `integer`):

Polite delay added before processing each page.

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

Apify Proxy is recommended because Makuake can block cloud datacenter requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.makuake.com/project/portable_refrigerator/"
    }
  ],
  "keywords": [],
  "excludeKeywords": [],
  "matchMode": "any",
  "keywordMatchScope": "title",
  "status": "all",
  "sortBy": "amount_raised",
  "resultsWanted": 20,
  "candidateLimit": 500,
  "maxPages": 10,
  "includeStory": false,
  "includeImages": true,
  "maxConcurrency": 3,
  "requestDelayMs": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset with one row per unique successfully collected project.

## `pageAudits` (type: `string`):

Non-billable listing-page audit records stored in the default key-value store.

## `runAudit` (type: `string`):

Non-billable run totals and failures stored in the default key-value store.

# 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 = {
    "startUrls": [
        {
            "url": "https://www.makuake.com/project/portable_refrigerator/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("research_master/makuake-project-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 = { "startUrls": [{ "url": "https://www.makuake.com/project/portable_refrigerator/" }] }

# Run the Actor and wait for it to finish
run = client.actor("research_master/makuake-project-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 '{
  "startUrls": [
    {
      "url": "https://www.makuake.com/project/portable_refrigerator/"
    }
  ]
}' |
apify call research_master/makuake-project-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,research_master/makuake-project-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/cpX8rKKgpM5hDfozr/builds/znVrP484T0a8BVTTI/openapi.json