# Wantedly Jobs Scraper (`automation-lab/wantedly-jobs-scraper`) Actor

Extract public Wantedly job/project listings with company names, roles, tags, descriptions, counters, and source URLs for recruiting intelligence.

- **URL**: https://apify.com/automation-lab/wantedly-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Wantedly Jobs Scraper

Extract public Wantedly job and project listings from Wantedly search pages. Get job titles, company names, role labels, hiring types, feature tags, public descriptions, engagement counters, and source URLs for recruiting lead generation and hiring-market monitoring.

### What does Wantedly Jobs Scraper do?

Wantedly Jobs Scraper turns public Wantedly project listing pages into structured dataset rows.

It visits Wantedly `/projects` pages over HTTP, reads the embedded Next.js/Apollo data, and saves each public job/project record to an Apify dataset.

Use it to monitor startup hiring in Japan, build recruiter prospect lists, enrich job-board pipelines, or track how companies describe open roles on Wantedly.

### Who is it for?

- Recruiters building target lists of companies currently hiring on Wantedly.
- Staffing and RPO agencies tracking active roles by category or hiring type.
- Job aggregators that need a reliable feed of public Wantedly project URLs.
- Market-intelligence teams monitoring startup hiring demand and role messaging.
- Sales teams looking for companies with current hiring activity.
- Data teams that want repeatable exports without maintaining Wantedly parsers.

### Why use this Wantedly scraper?

- Public-data only: no login, no applicant messaging, no private account features.
- HTTP-first extraction: fast and inexpensive compared with browser automation.
- Pagination support: scrape more than the first visible listing page.
- Rich fields: includes company, role, tags, descriptions, counters, and source metadata.
- Apify-ready: schedule runs, export datasets, call by API, or connect with MCP.

### What data can you extract?

| Field | Description |
| --- | --- |
| `jobId` | Wantedly job/project ID |
| `url` | Public Wantedly project URL |
| `title` | Job or project title |
| `companyName` | Company name shown on Wantedly |
| `companyUrl` | Public Wantedly company profile URL when available |
| `occupationName` | Role or occupation label |
| `hiringTypes` | Hiring types such as intern, mid-career, side job, freelance |
| `featureTags` | Public Wantedly tags such as online interview or student friendly |
| `description` | Full public description when enabled and present |
| `descriptionSnippet` | Short text preview for quick review |
| `imageUrl` | Cover image URL |
| `totalEntriesCount` | Public entry/application-interest count when present |
| `totalBookmarksCount` | Public bookmark count when present |
| `totalSupportersCount` | Public supporter count when present |
| `publishedAt` | Published timestamp when present |
| `sourcePageUrl` | Listing page where the item was found |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Wantedly jobs?

This actor uses pay-per-event pricing.

- Start event: a small one-time charge per run.
- Item event: a tiered charge per Wantedly job record saved.

Final platform pricing is calculated from realistic cloud-run cost measurements before publication. The actor is designed as an HTTP scraper to keep compute cost low.

### How to use Wantedly Jobs Scraper

1. Open the actor on Apify.
2. Add one or more Wantedly project listing URLs.
3. Set `maxItems` to the number of job records you need.
4. Set `maxPages` high enough to cover the expected pagination.
5. Keep `includeDescription` enabled if you need full public job descriptions.
6. Start the run.
7. Download the dataset as JSON, CSV, Excel, XML, RSS, or via API.

### Input options

#### `startUrls`

Wantedly project listing or filtered search URLs.

Default example:

```json
[{ "url": "https://www.wantedly.com/projects" }]
````

#### `maxItems`

Maximum number of Wantedly job/project records to save.

Use small values for tests and higher values for scheduled monitoring.

#### `maxPages`

Maximum number of listing pages to request per start URL.

Wantedly pages usually return around ten primary project records per page, so a `maxItems` value of 100 may need roughly 10 to 15 pages.

#### `includeDescription`

When enabled, the actor includes the full public job description if it is embedded in the listing page data.

Disable it if you only need compact lead rows.

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.wantedly.com/projects" }
  ],
  "maxItems": 50,
  "maxPages": 10,
  "includeDescription": true
}
```

### Example output

```json
{
  "jobId": "749971",
  "url": "https://www.wantedly.com/projects/749971",
  "title": "英語・海外・国際交流が好きな人！好きを仕事にしませんか？長期インターン募集",
  "companyName": "株式会社R",
  "companyUrl": "https://www.wantedly.com/companies/company_4391985",
  "occupationName": "Webマーケティング",
  "hiringTypes": ["学生インターン"],
  "featureTags": ["留学生さん歓迎", "オンライン面談OK"],
  "totalEntriesCount": 413,
  "totalBookmarksCount": 502,
  "publishedAt": "2021-10-07T09:36:32.861Z",
  "sourcePageUrl": "https://www.wantedly.com/projects",
  "scrapedAt": "2026-07-08T06:06:40.637Z"
}
```

### Tips for better results

- Start with `maxItems` 20 to verify your filters.
- Use Wantedly's own project search page URLs for role/category filtering.
- Increase `maxPages` when `maxItems` is much larger than 10.
- Keep descriptions enabled for qualitative hiring analysis.
- Schedule recurring runs if you need a fresh hiring feed.

### Integrations

Use the dataset in:

- Recruiting CRMs for company and role prospecting.
- Google Sheets or Airtable for hiring-market tracking.
- BI dashboards for startup hiring trends.
- Data enrichment pipelines for job aggregator pages.
- Sales workflows that trigger outreach when a company starts hiring.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/wantedly-jobs-scraper').call({
  startUrls: [{ url: 'https://www.wantedly.com/projects' }],
  maxItems: 50,
  maxPages: 10,
  includeDescription: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/wantedly-jobs-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.wantedly.com/projects'}],
    'maxItems': 50,
    'maxPages': 10,
    'includeDescription': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~wantedly-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.wantedly.com/projects"}],"maxItems":50,"maxPages":10,"includeDescription":true}'
```

### MCP usage

Connect Apify MCP to Claude Desktop or Claude Code with this actor enabled:

```bash
claude mcp add apify-wantedly-jobs --transport http "https://mcp.apify.com/?tools=automation-lab/wantedly-jobs-scraper"
```

Claude Desktop JSON configuration example:

```json
{
  "mcpServers": {
    "apify-wantedly-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/wantedly-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 50 Wantedly job posts and summarize the most common hiring types."
- "Find companies hiring marketing interns on Wantedly and return a CSV-ready table."
- "Monitor Wantedly jobs weekly and highlight new companies with remote-friendly tags."

### Scheduling and monitoring

Create an Apify schedule to run the actor daily or weekly.

Use dataset exports or webhooks to send new rows into your warehouse, CRM, or spreadsheet.

For recurring monitoring, use a stable Wantedly listing URL and keep the same input between runs.

### Data quality notes

Wantedly can change labels, pagination, or embedded data structures.

The actor saves only fields available publicly in the page payload at run time.

Some records may not contain every counter, tag, or description field.

### Legality and public-data scope

This actor extracts public Wantedly project information that is visible without login.

It does not access private accounts, applicant messages, user dashboards, or authenticated workflows.

Always review your use case and comply with applicable laws, platform terms, and privacy requirements.

### FAQ and troubleshooting

#### Why did I get fewer items than `maxItems`?

Increase `maxPages`. Some listing pages include fewer extractable records after de-duplication.

#### Why is a field missing?

Wantedly does not expose every field on every project. Missing optional fields are omitted from the dataset row.

#### Can I scrape a specific company page?

This version focuses on project listing/search pages. Use a Wantedly projects URL that includes the relevant filters where possible.

### Related scrapers

Explore related automation-lab actors on Apify:

- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/google-jobs-scraper
- https://apify.com/automation-lab/indeed-jobs-scraper
- https://apify.com/automation-lab/company-website-scraper

### Output schema stability

The main job fields are designed to remain stable after publication.

New optional fields may be added when Wantedly exposes additional public data.

### Support

If a run fails, share the run URL, input, and expected Wantedly page with support.

For best support results, include the start URL and a small `maxItems` value that reproduces the issue.

# Actor input Schema

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

Wantedly public project listing URLs to scrape. Use https://www.wantedly.com/projects or filtered project-search URLs from Wantedly.

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

Maximum Wantedly job/project records to save.

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

Maximum paginated Wantedly listing pages to visit per start URL. Leave the default for most runs.

## `includeDescription` (type: `boolean`):

Save the full public Wantedly job description when it is present in the page data.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.wantedly.com/projects"
    }
  ],
  "maxItems": 20,
  "maxPages": 10,
  "includeDescription": true
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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.wantedly.com/projects"
        }
    ],
    "maxItems": 20,
    "maxPages": 10,
    "includeDescription": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/wantedly-jobs-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.wantedly.com/projects" }],
    "maxItems": 20,
    "maxPages": 10,
    "includeDescription": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/wantedly-jobs-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 '{
  "startUrls": [
    {
      "url": "https://www.wantedly.com/projects"
    }
  ],
  "maxItems": 20,
  "maxPages": 10,
  "includeDescription": true
}' |
apify call automation-lab/wantedly-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wantedly Jobs Scraper",
        "description": "Extract public Wantedly job/project listings with company names, roles, tags, descriptions, counters, and source URLs for recruiting intelligence.",
        "version": "0.1",
        "x-build-id": "5DEfPylTsL1k5JYCk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~wantedly-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-wantedly-jobs-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/automation-lab~wantedly-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-wantedly-jobs-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/automation-lab~wantedly-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-wantedly-jobs-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": "Wantedly project/listing URLs",
                        "type": "array",
                        "description": "Wantedly public project listing URLs to scrape. Use https://www.wantedly.com/projects or filtered project-search URLs from Wantedly.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum Wantedly job/project records to save.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum listing pages",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum paginated Wantedly listing pages to visit per start URL. Leave the default for most runs.",
                        "default": 10
                    },
                    "includeDescription": {
                        "title": "Include full public description",
                        "type": "boolean",
                        "description": "Save the full public Wantedly job description when it is present in the page data.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
