# Wanted Korea Job Scraper — Korean Tech Jobs & Hiring Companies (`youfuxu/wanted-korea-tech-jobs-scraper`) Actor

Scrape jobs from Wanted (wanted.co.kr), Korea's leading tech & startup job platform. Titles, hiring companies, Seoul districts, experience range, job categories, referral rewards, deadlines and full descriptions as clean JSON. Also covers Wanted Japan, Taiwan and Singapore.

- **URL**: https://apify.com/youfuxu/wanted-korea-tech-jobs-scraper.md
- **Developed by:** [Youfu Xu](https://apify.com/youfuxu) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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

## Wanted Korea Job Scraper — Korean tech jobs, hiring companies & referral rewards

Get clean, structured job data from **[Wanted](https://www.wanted.co.kr)** (원티드) — the job platform Korean startups and tech companies use to hire developers, data scientists, product managers, designers and marketers. Search any keyword in Korean or English and download the results as JSON, CSV or Excel. No login, no browser, no proxy setup. The same Actor also reaches Wanted's **Japan, Taiwan and Singapore** boards through the `country` input.

### What you get

Run it with the default input and results look like this:

```json
{
  "url": "https://www.wanted.co.kr/wd/378627",
  "jobId": 378627,
  "title": "[플레이오] Backend Engineer (Python)",
  "companyName": "지엔에이컴퍼니",
  "companyUrl": "https://www.wanted.co.kr/company/24775",
  "industry": "IT, 컨텐츠",
  "location": "서울",
  "district": "서초구",
  "fullAddress": "서울시 서초구 방배로 27길 8, 3층",
  "country": "한국",
  "experienceMinYears": 2,
  "experienceMaxYears": null,
  "experienceText": "2+ years",
  "categories": ["파이썬 개발자"],
  "categoryGroup": "개발",
  "rewardText": "100만원",
  "rewardTotal": 1000000,
  "rewardCurrency": "KRW",
  "deadline": null,
  "isRollingDeadline": true,
  "status": "active",
  "applicationResponseRate": 26.83,
  "applicationResponseLevel": "very_low",
  "logoUrl": "https://static.wanted.co.kr/images/wdes/0_5.4ccebd36.jpg",
  "scrapedAt": "2026-08-21T02:18:47.355Z"
}
```

**40 fields per job by default**, including the hiring company and its Wanted profile, Seoul district and full street address, the required experience range, Wanted's job-category names (not just IDs), the referral reward as both the original text and a number in KRW, the application deadline, and how quickly the company tends to answer applicants.

Turn on **Include detail page data** and each job grows to **53 fields**: the full posting as plain text (`description`) and HTML (`descriptionHtml`), split into `intro`, `mainTasks`, `requirements`, `preferredPoints` and `benefits`, plus `skills` (e.g. `["Python", "AWS", "MySQL"]`), `companyTags` (e.g. 재택근무, 퇴사율5%이하, 스타트업), office `latitude` / `longitude` and company photos.

### Who uses this

- **Recruiters & sourcing agencies** — see which Korean companies are hiring for which roles right now, with experience requirements and office districts
- **Lead generation** — every row carries the company name, industry, Wanted company page, address and logo; filter by `companyTags` like 스타트업 or 인원급성장 to find fast-growing targets
- **Job boards & alert bots** — poll a keyword daily and diff against yesterday's dataset; `jobId` is stable and `deadline` tells you when a posting closes
- **Market & labour research** — count machine-learning, backend or PM openings across Seoul, Gyeonggi, Busan and Daejeon, or across Wanted Japan and Singapore
- **Skill-demand analysis** — with details on, aggregate `skills` to see which frameworks Korean employers ask for this quarter

### How to use

1. Enter a **keyword** — `python`, `백엔드`, `data engineer`, `프로덕트 매니저`, `react` all work
2. Pick a **country** — `kr` (Korea, default), `jp`, `tw`, `sg` or `all`
3. Optionally narrow by **location** (`seoul.all`, `seoul.gangnam-gu`, `gyeonggi.seongnam-si`, `busan.all`), **years of experience** (`0` = entry level) or **job category IDs** (`518` = all development roles, `899` = Python developer, `655` = data engineer, `1634` = ML engineer)
4. Set **Max jobs** (default 50; Wanted serves up to 100 per request, so large exports are fast)
5. Optionally enable **Include detail page data** for full descriptions, skills and company tags
6. Run, then download from the **Dataset** tab as JSON / CSV / Excel, or pull it through the Apify API

#### Example input

```json
{
  "keyword": "머신러닝",
  "country": "kr",
  "locations": "seoul.all",
  "years": 3,
  "sortBy": "job.popularity_order",
  "maxItems": 300,
  "includeDetails": true
}
```

### Output fields

| Field | Description |
| --- | --- |
| `url` | Public job page, `https://www.wanted.co.kr/wd/<jobId>` |
| `jobId` | Wanted's numeric job ID (stable across runs) |
| `title` | Position title as posted |
| `companyName`, `companyId`, `companyUrl` | Hiring company and its Wanted profile |
| `industry` | Company industry label, e.g. `IT, 컨텐츠`, `금융` |
| `location`, `district`, `fullAddress`, `country` | City (서울, 경기, 부산…), district (강남구…), street address and country |
| `locationKey`, `districtKey` | Wanted's filter keys, e.g. `seoul` / `seoul.gangnam-gu` — reuse them in the `locations` input |
| `experienceMinYears`, `experienceMaxYears`, `experienceText` | Required experience; `experienceMaxYears` is `null` when Wanted leaves the range open (e.g. `5+ years`) |
| `categories`, `categoryGroup`, `categoryIds` | Job-category names (파이썬 개발자, 데이터 엔지니어…), their parent group (개발, 마케팅·광고…) and raw IDs |
| `rewardText`, `rewardTotal`, `rewardRecommender`, `rewardRecommendee`, `rewardCurrency` | Referral reward Wanted pays on a successful hire, as text (`100만원`) and numbers in KRW |
| `deadline`, `isRollingDeadline` | Application deadline (`YYYY-MM-DD`) or `true` when the posting stays open until filled (상시채용) |
| `status`, `likeCount` | Posting status and number of bookmarks |
| `applicationResponseRate`, `applicationResponseLevel` | Share of applicants the company replied to and Wanted's label for it (`very_low` → `high`) |
| `logoUrl`, `coverImageUrl` | Company logo and the posting's cover image |
| `employmentType`, `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | Reserved for schema compatibility with our other job scrapers — Wanted does **not** publish salary or contract type, so these are empty (see Limitations) |
| `scrapedAt` | ISO timestamp of the scrape |
| *Detail mode only:* `description`, `descriptionHtml` | Full posting — all sections joined as plain text, and as simple HTML (`<h3>` headings + `<p>` paragraphs) |
| *Detail mode only:* `intro`, `mainTasks`, `requirements`, `preferredPoints`, `benefits` | The five sections Wanted structures every posting into |
| *Detail mode only:* `skills`, `companyTags` | Skill tags (Python, Kubernetes…) and company perks / traits (재택근무, 스톡옵션, 설립4~9년…) |
| *Detail mode only:* `countryCode`, `latitude`, `longitude`, `companyImages`, `isCrossBorder` | ISO country code, office coordinates, company photos, and whether the role is a cross-border hire |

### Limitations

- **No salary data.** Wanted does not display salaries on job postings (the site's "compensation" sort refers to the referral reward). The `salary*` fields exist so datasets line up with our other job scrapers, but they are always empty. Use `rewardTotal` as a rough signal of how hard a role is to fill
- **Korea is the deep catalogue.** Wanted's Japan, Taiwan and Singapore boards are much smaller; a niche keyword may return only a handful of jobs there. Try `country=all` or a broader term
- Category names are fetched from Wanted's public tag list at run time; if that request ever fails the run continues and `categories` falls back to an empty array while `categoryIds` is still filled
- Keyword search is Wanted's own full-text search — it matches titles and descriptions, so a very generic word like `개발자` will return thousands of jobs

### Legal

This Actor only reads publicly available job listings that Wanted shows to any visitor without logging in. Please respect Wanted's terms of service and use the data responsibly — for example, do not re-post listings without attribution.

### FAQ

**Does it need a proxy?**
No. It works from Apify's own servers without residential proxies.

**How fresh is the data?**
Results are read live from Wanted's listing feed, newest first by default. Schedule the Actor daily and diff on `jobId` to catch new postings and closed ones.

**Can I get every job in a category?**
Yes — use a broad keyword plus `categoryTagIds` (e.g. `518` for all development roles) and raise `maxItems`. The log prints progress every page.

**How many requests does a run make?**
One per 100 jobs without details, plus one per job when `includeDetails` is on. A 500-job export with details takes roughly 10–12 minutes because the Actor paces itself politely.

# Actor input Schema

## `keyword` (type: `string`):

What to search for, e.g. <code>python</code>, <code>백엔드</code>, <code>data engineer</code>, <code>PM</code>. Korean and English both work.

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

Which Wanted site to search. <code>kr</code> is Korea (by far the largest). <code>jp</code>, <code>tw</code> and <code>sg</code> are Wanted's Japan, Taiwan and Singapore boards; <code>all</code> searches every country at once.

## `locations` (type: `string`):

Wanted location key. <code>all</code> for everywhere, <code>seoul.all</code> for all of Seoul, or a district such as <code>seoul.gangnam-gu</code>, <code>seoul.seocho-gu</code>, <code>gyeonggi.seongnam-si</code>, <code>busan.all</code>. The key is visible in the <code>locations=</code> part of the URL when you filter on wanted.co.kr.

## `years` (type: `integer`):

Filter by required experience. <code>-1</code> = any, <code>0</code> = entry level / new graduates, <code>1</code>–<code>10</code> = jobs whose experience range includes that many years.

## `categoryTagIds` (type: `string`):

Optional comma-separated Wanted category IDs to restrict the search, e.g. <code>518</code> (all development roles), <code>872</code> (server developer), <code>899</code> (Python developer), <code>655</code> (data engineer), <code>1634</code> (machine-learning engineer), <code>669</code> (frontend), <code>674</code> (DevOps). Every result also carries its category names, so you can discover IDs from a first run.

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

Order results the way Wanted does: newest first, most popular first, or highest referral reward first.

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

Maximum number of jobs to return (Wanted serves up to 100 per request). Keep it small for a quick test, raise it for a full export.

## `includeDetails` (type: `boolean`):

Fetch each job's detail record to add the full description (intro, responsibilities, requirements, preferred skills, benefits — as plain text and HTML), the skill tags, company tags and office coordinates. One extra request per job, so it is slower; the listing already includes title, company, location, experience range, categories, referral reward and deadline without it.

## Actor input object example

```json
{
  "keyword": "python",
  "country": "kr",
  "locations": "all",
  "years": -1,
  "categoryTagIds": "",
  "sortBy": "job.latest_order",
  "maxItems": 50,
  "includeDetails": false
}
```

# Actor output Schema

## `datasetItemsJson` (type: `string`):

All scraped records as a JSON array.

## `datasetItemsCsv` (type: `string`):

All scraped records as a CSV file.

## `datasetItemsXlsx` (type: `string`):

All scraped records as an Excel workbook.

## `dataset` (type: `string`):

The default dataset of this run in Apify Console.

# 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 = {
    "keyword": "python",
    "country": "kr",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("youfuxu/wanted-korea-tech-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 = {
    "keyword": "python",
    "country": "kr",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("youfuxu/wanted-korea-tech-jobs-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 '{
  "keyword": "python",
  "country": "kr",
  "maxItems": 50
}' |
apify call youfuxu/wanted-korea-tech-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,youfuxu/wanted-korea-tech-jobs-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/D4DBj8YzyxyQ49rg7/builds/7DqryhrWLF9K0sPpB/openapi.json
