# Green Japan Job Scraper (`superslowsloth/green-japan-job-scraper`) Actor

Scrape Japanese tech job listings from Green, one of Japan's largest IT job boards. Returns job title, company, salary range parsed into yen, prefecture, required skills, company size and founding year. Japanese text is returned exactly as published, never transliterated.

- **URL**: https://apify.com/superslowsloth/green-japan-job-scraper.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.28 / 1,000 job listings

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/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

## Green Japan Job Board Scraper

Returns job offers from [Green](https://www.green-japan.com), one of Japan's
largest tech-focused job boards: the job title, the hiring company, the printed
salary band, the work location, the required skills and the canonical URL of the
listing.

Search in English or Japanese. `python`, `React`, `機械学習` and `営業` all work.

### Japanese text is returned exactly as Green prints it

Nothing is translated, transliterated or romanised, and nothing is re-encoded.
`株式会社 DEGINA` comes back as `株式会社 DEGINA`, and `430万円〜550万円` comes
back as `430万円〜550万円`. The salary band is *also* parsed into plain yen
integers so it can be sorted and filtered, but the original string is always
kept beside it.

### Output fields

| Field | Notes |
|---|---|
| `id` | Green's numeric job-offer id. |
| `url` | Canonical listing URL, e.g. `https://www.green-japan.com/company/11242/job/324553`. |
| `name` | The job title, e.g. `Webディレクター（制作部リーダー候補）`. |
| `title` | The longer headline Green shows above the job. A different field from `name`. |
| `company_id`, `company_name` | The hiring company. |
| `company_title` | The company's one-line pitch. `null` when it has none. |
| `salary` | The band exactly as printed, e.g. `430万円〜550万円`. |
| `salary_min_jpy`, `salary_max_jpy` | Yen integers read out of `salary`. |
| `area_name` | Location string as printed, e.g. `東京都, フルリモート`. |
| `area_names` | The same string split on its separators, for filtering. |
| `skill_names` | Skills tagged on the offer, e.g. `["Python", "AWS", "React"]`. Often empty. |
| `tag_names` | Green's own labels, e.g. `["副業可"]`. |
| `business_name`, `business_introduction`, `business_photo_url` | The business unit the role sits in, and its blurb. |
| `photo_urls` | Listing photos. |
| `employees_number` | Company headcount. |
| `established_year` | As printed, e.g. `2015年`. |
| `established_year_int` | The four-digit year, e.g. `2015`. |
| `updated_at_timestamp`, `updated_at` | When the offer was last updated, as Unix seconds and as ISO-8601 UTC. |
| `is_new` | Green's own "new" flag. |
| `other_job_offer_count` | How many other openings the same company had alongside this one. |
| `keyword` | Which of your search terms produced this row. |

### What this source does not give

These are stated rather than guessed. A missing value is always `null`, never
`0` and never an empty string, because a zero reads as a measurement that was
never taken.

- **No posting date.** Green publishes only a last-updated timestamp, which is
  what `updated_at` is. It is not the date the job was first listed.
- **No job description, requirements or benefits.** The search payload carries
  the summary card only. The full text lives on the individual listing page at
  `url`.
- **No application deadline, employment type or contract length.**
- **`skill_names` is frequently empty** - measured on 360 offers across six
  keywords, 201 of them carried no skill tags at all. That is Green's data, not
  a parsing gap.
- **`established_year` is occasionally absent** (7 of those same 360).
- **The other openings at the same company are counted, not copied.** One
  company's catalogue reached 31 KB inside a single search row, which would have
  tripled the size of every dataset item to repeat data that a second search
  returns properly. `other_job_offer_count` records how many there were.

### Two measured limits worth knowing before you run this

**Green paginates only three pages deep.** `page=2` and `page=3` return offers
that do not overlap page 1 at all, but `page=10`, `page=280` and `page=999` all
redirect back to page 3 and re-serve it. So a keyword yields at most **60 jobs**,
no matter that the site reports 5,586 results for `python`. To collect more,
give the actor more keywords - results are merged and de-duplicated by job id, so
a job matching several of your keywords is delivered once and charged once.

**The `/search_key` URL does not search.** It answers 200 and it looks right, but
it redirects to `/search` and drops the keyword on the way, so it serves the
generic unfiltered board - the identical twenty offers whether you ask it for
`python` or for gibberish. This actor uses `/search?keyword=`, which honours the
term. A contract test pins that behaviour so we notice if Green ever fixes it.

### Input

| Field | Notes |
|---|---|
| `keywords` | Required. One or more search terms, English or Japanese. |
| `maxItems` | Budget for the whole run across all keywords, not per keyword. Default 60. |
| `proxyConfiguration` | Optional. Green answered without a proxy when this was built; a proxy just gives the scraper a fresh address to retry on. |

### Billing

One `job-scraped` event per job, charged after the job has been written to the
dataset, and only for jobs that are actually delivered. A duplicate is never
charged. A keyword that matches nothing costs nothing beyond the actor start.

# Actor input Schema

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

One or more terms to search Green for. English and Japanese both work - try "python", "React", "機械学習" or "営業". Each keyword is searched separately and the results are merged, with any job that matches more than one keyword delivered and charged only once.

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

Budget for the whole run, across all keywords, not per keyword. Green only paginates three pages deep, so a single keyword can yield at most 60 jobs however large its result count looks; add more keywords to go past that.

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

Optional. Green answered without a proxy when this actor was built, but a proxy gives the scraper a fresh exit address to retry on if the site starts refusing requests from the platform's own addresses.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "maxItems": 60,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "keywords": [
        "python"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/green-japan-job-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 = {
    "keywords": ["python"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/green-japan-job-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 '{
  "keywords": [
    "python"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call superslowsloth/green-japan-job-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,superslowsloth/green-japan-job-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/rPemgDxwjAiQ4BIIl/builds/HuCDSxYSB1giZA1gM/openapi.json