# TokyoDev Jobs Scraper (`rl1987/tokyodev-jobs-scraper`) Actor

Scrapes IT job listings for English speakers in Japan from TokyoDev.com, including title, company, location, remote status, salary, tags, and full job description.

- **URL**: https://apify.com/rl1987/tokyodev-jobs-scraper.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** Jobs
- **Stats:** 1 total users, 0 monthly users, 96.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job listings

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## TokyoDev Jobs Scraper

### What does TokyoDev Jobs Scraper do?

**TokyoDev Jobs Scraper** extracts every IT job listing for English-speaking developers in Japan from [TokyoDev.com/jobs](https://www.tokyodev.com/jobs) — the leading job board for tech roles at Japanese and Japan-based international companies. For each job it captures the title, company, location, remote/hybrid/onsite status, salary range, Japanese/English language requirements, seniority level, skill tags, and the full job description.

Try it instantly: set `maxItems` to a small number (e.g. 10) and click **Start**. Because it runs on the Apify platform, you also get scheduled runs (e.g. daily to catch newly posted jobs), API/webhook access to the data, monitoring, and export to any format without writing a line of code.

### Why use TokyoDev Jobs Scraper?

- **Recruiters & sourcers** — build a live feed of open engineering roles at Japan-based companies without manually browsing the site.
- **Job seekers & career-move automation** — pipe fresh listings into a spreadsheet, Slack channel, or job-alert bot filtered by tech stack or Japanese-language requirement.
- **Market research** — analyze salary bands, remote-work policies, and in-demand skills across the Japanese tech job market over time.
- **Aggregators** — feed a broader job board or newsletter with structured TokyoDev listings.

### How to use TokyoDev Jobs Scraper

1. Click **Start** (no input is required — defaults scrape all currently open jobs with full details).
2. Optionally set `maxItems` to cap how many jobs are scraped, pick a `category` from the dropdown (e.g. Ruby, Backend, Fully remote), or set `keyword` for a full-text search over job title and description.
3. Run the Actor and wait for it to finish — a typical full run scrapes 100-200 jobs in a few minutes.
4. Open the **Dataset** tab to view, filter, and export the results as JSON, CSV, Excel, HTML, or XML.

### Input

| Field | Type | Description |
|---|---|---|
| `maxItems` | integer | Max number of jobs to scrape. `0` = unlimited (all currently listed jobs). Default `100`. |
| `category` | string | Optional category/skill/remote/eligibility filter, picked from a dropdown (63 options: languages, frameworks, disciplines, remote/Japanese-level/eligibility tags). Filters server-side. |
| `keyword` | string | Optional free-text search, passed straight to TokyoDev's own site search. Full-text over job title and description, not just a title/company match. Combines with `category`. |
| `fetchJobDetails` | boolean | Whether to fetch each job's detail page for the full description, structured salary, posted date, and language/seniority requirements. Default `true`. Disable for a much faster summary-only run. |
| `proxyConfiguration` | object | Apify Proxy configuration. Not required by default — the Actor uses a browser-impersonating HTTP client that passes TokyoDev's Cloudflare check on its own. |

See the **Input** tab in Apify Console for the full schema and defaults.

### Output

Each dataset item looks like this (abbreviated):

```json
{
  "title": "Senior Ruby on Rails Developer",
  "company": "ANDPAD",
  "location": "Chiyoda-ku, Tokyo",
  "remoteStatus": "Partially remote",
  "jobUrl": "https://www.tokyodev.com/companies/andpad/jobs/senior-ruby-on-rails-developer",
  "categoryTags": ["Backend", "Ruby"],
  "salaryMin": 7000000,
  "salaryMax": 12000000,
  "salaryCurrency": "JPY",
  "japaneseLevel": "Conversational Japanese",
  "englishLevel": "Business English",
  "seniorityLevel": "Senior level",
  "postedDate": "2024-11-01T07:48:33.777+09:00",
  "descriptionSummary": "We are seeking a Senior Ruby on Rails Developer..."
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel from the Apify Console or via the API.

### Data table

| Field | Description |
|---|---|
| `title` | Job title |
| `company` / `companyUrl` / `companyLogoUrl` | Hiring company |
| `location` | City / prefecture in Japan |
| `remoteStatus` | Fully remote / Partially remote / No remote |
| `eligibility` | "Apply from abroad" or "Japan residents only" |
| `japaneseLevel` / `englishLevel` | Required language proficiency |
| `seniorityLevel` / `experienceRequired` | Seniority tier and years of experience |
| `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` | Structured salary range |
| `categoryTags` | Skill/category tags (e.g. Backend, Ruby, AWS) |
| `postedDate` | ISO date the job was originally posted |
| `descriptionHtml` / `descriptionText` / `descriptionSummary` | Full job description |
| `jobUrl` | Canonical URL of the job posting |

### Pricing

This Actor uses the **Pay-Per-Event** pricing model: you are charged **$0.001 per scraped job listing** returned in the dataset. A full run of ~150 jobs costs roughly $0.15. There is a minimal charge cap; you control the maximum spend per run via the "Max total charge" setting on the Apify Console run form.

### Tips

- Set `fetchJobDetails` to `false` for a fast overview run (title, company, salary range, tags) — useful for monitoring new postings before doing a full detail pull.
- Combine `category` and `keyword` to narrow down to a specific niche, e.g. `category: "ruby"` + `keyword: "senior"`.
- Schedule a daily run and diff the dataset (by `jobUrl`) to alert on newly posted jobs.

### FAQ, disclaimers, and support

This Actor only accesses publicly available job listing pages on tokyodev.com. It is intended for personal research, job search, and recruiting use; respect TokyoDev's Terms of Service when using the scraped data. TokyoDev's listing page shows all currently open positions on a single page (no pagination), so results reflect a point-in-time snapshot of active listings.

Found a bug or have a feature request? Open an issue in this Actor's Issues tab. Need a customized version (different site, additional fields, scheduled delivery)? Feel free to reach out for a custom solution.

### Job search toolkit

Part of the **Job search toolkit** — job listing data across major tech employers and niche job boards:

- [FAANG Job Search Scraper](https://apify.com/rl1987/faang-jobs) — Scrapes job listings by search query and location from Meta, Amazon, Apple, Netflix, and Google.
- [Dynamite Jobs Scraper](https://apify.com/rl1987/dynamitejobs-scraper) — Scrapes remote job listings from dynamitejobs.com with search and filtering.
- [OSINT Jobs Scraper](https://apify.com/rl1987/osint-jobs-scraper) — Scrapes job listings (title, company, location, salary, description) from osint-jobs.com.

### Did you find this useful?

Rate this actor on Apify! Your feedback helps other users find it and helps us keep improving it.

# Actor input Schema

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

Maximum number of job listings to scrape. Set to 0 for unlimited (scrapes every job currently listed on TokyoDev, typically 100-200).

## `category` (type: `string`):

Optional category/skill/remote/eligibility tag to filter the listing server-side. Pick one from the dropdown -- matches the tag filters at https://www.tokyodev.com/jobs/<slug>. Leave as "(none)" to scrape all jobs, and combine with Keyword search below to narrow further.

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

Optional free-text search, passed straight to TokyoDev's own site search (?query=...). This is a real full-text search over job title and description, not just a title/company substring match, and combines with Category above.

## `fetchJobDetails` (type: `boolean`):

For every matched job, also fetch its detail page to get the full description, structured salary, posted date, location, seniority, and language requirements. Disable to only get the summary fields already shown on the listing page (title, company, tags, salary range) for a much faster run.

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

The Actor uses a browser-impersonating HTTP client that passes TokyoDev's Cloudflare check for the job listing page without a proxy, but job detail pages 403 from Apify's datacenter IPs -- a residential proxy is required on the platform to fetch full job details.

## Actor input object example

```json
{
  "maxItems": 100,
  "category": "",
  "fetchJobDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `jobs` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/tokyodev-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/tokyodev-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 '{}' |
apify call rl1987/tokyodev-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rl1987/tokyodev-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/gfZHmRhxR2foayDLR/builds/0C6UaAurqgdqXidD2/openapi.json