# 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:** 3 total users, 2 monthly users, 100.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/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

## 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.

# 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/RNDJGLPgh48iSH3PZ/openapi.json