# TokyoDev Scraper: Japan Tech Jobs & Companies (`getascraper/tokyo-dev-scraper`) Actor

Scrape job listings and company profiles from TokyoDev.com. Extract job titles, companies, locations, remote policies, salary ranges, Japanese language requirements, visa sponsorship, and technology tags. Drop-in for HubSpot, Salesforce, and Airtable. $1.99 per 1,000 results.

- **URL**: https://apify.com/getascraper/tokyo-dev-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Jobs, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 jobs

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

## TokyoDev Scraper: Japan Tech Jobs

**TokyoDev job board scraper and Japanese tech recruitment data extraction API.** Extract public tech job vacancies, hiring companies, parsed salary ranges, remote work policies, required Japanese language levels, visa sponsorship eligibility, and technology stack tags from tokyodev.com with this Apify Actor. Bypasses blocking without browser overhead using fast, static Cheerio code, delivering clean structured datasets ready for recruiters, job aggregators, or HR analysts.

Whether you are a global recruitment agency sourcing English-speaking tech talent in Japan, an HR analyst tracking local developer compensation benchmarking, or a B2B sales representative hunting for funded startup leads expanding in Tokyo, this Actor delivers complete recruitment datasets on a scheduled basis.

---

### What does TokyoDev Scraper do?

* **Highly Optimized Performance:** Scrapes listings directly via server-side rendered (SSR) HTML, bypassing the massive compute and memory overhead of headless browsers like Playwright or Puppeteer.
* **Resilient Sitemap Discovery:** Parses `sitemap.xml` automatically to discover all active jobs and company profile pages, enabling complete catalog crawls with minimal request counts.
* **Pre-filtered Extraction:** Filters listings by remote policy, seniority, JPY salary threshold, target tech tags, and Japanese language requirement before saving, ensuring only high-intent records land in your database.
* **Precise Salary Parsing:** Normalizes salary text on-the-fly, extracting minimum and maximum bounds in JPY.

---

### Why use TokyoDev Scraper?

TokyoDev is Japan's premier English-language tech job directory, hosting thousands of active vacancies from high-paying startups and multinational giants (such as PayPay, Mercari, and Money Forward).

Use this Actor to:
1. **Squeeze Tech Leads:** Target growing engineering organizations and start-ups hiring developers directly in Tokyo.
2. **Benchmark Local Tech Compensation:** Extract precise JPY salary boundaries to benchmark engineering salaries in Japan.
3. **Populate Job Directories:** Aggregate and ingest foreign-friendly and English-speaking software developer listings into your own search portals.

---

### How to Scrape TokyoDev Data Step-by-Step

1. Open the **Input** tab in Apify Console.
2. Configure **Scrape Mode** (choose from job listings, company profiles, or both).
3. Apply filters like **Search Keyword** (e.g. "SRE"), **Minimum Salary JPY** (e.g. 8000000), **Target Tech Tags** (e.g. `["Go", "Kubernetes"]`), **Remote Policy** (fully-remote, partially-remote) or **Japanese Language Filter** (no-japanese-required).
4. Click **Start** and export your clean dataset.

---

### Input

| Field | Type | Description | Default |
|---|---|---|---|
| `scrapeMode` | string | `jobs` (listings only), `companies` (profiles only), or `both`. | `"jobs"` |
| `searchQuery` | string | Perform free-text keyword matching across titles, tags, and descriptions. | `""` |
| `minSalary` | integer | Filter out jobs with maximum annual JPY salaries below this threshold (e.g., `8000000`). | `0` |
| `techTags` | array | List of specific technology tags (e.g., `["TypeScript", "Go", "React"]`). | `[]` |
| `remotePolicy` | string | Filter results by remote policy (fully-remote, partially-remote, no-remote). | `""` |
| `japaneseRequired` | string | Filter results by Japanese requirement (japanese-required, no-japanese-required). | `""` |
| `applyFromAbroad` | string | Filter listings based on candidate residency rules (abroad-only, residents-only). | `""` |
| `searchUrls` | array | Paste specific TokyoDev job links or company URLs to scrape directly. Bypasses sitemaps. | `[]` |
| `maxItems` | integer | Hard cap on total results returned. | `50` |
| `proxyConfiguration` | object | Proxy settings. Standard datacenter proxies are recommended. | `{"useApifyProxy": true}` |

---

### Output Example

#### Job Listing Record

```json
{
  "job_title": "Frontend Engineer-Junior/Mid",
  "company_name": "RESTAR",
  "company_url": "https://www.careercross.com/en/company/detail-545260",
  "location": "Minato-ku, Tokyo",
  "job_type": "full-time",
  "seniority": "junior",
  "remote_policy": "partially-remote",
  "japanese_required": false,
  "apply_from_abroad": true,
  "salary_min": 4500000,
  "salary_max": 8500000,
  "salary_currency": "JPY",
  "description": "We are building the REMETIS platform, making it easier for real estate...",
  "requirements": [
    "You have experience building complex user interfaces.",
    "You enjoy writing clean, well-tested code."
  ],
  "tags": [
    "Elixir",
    "TypeScript",
    "React",
    "Vue.js"
  ],
  "posted_date": "2026-06-07",
  "job_url": "https://www.tokyodev.com/companies/restar/jobs/frontend-engineer-junior-mid",
  "scraped_at": "2026-06-07T02:30:15.000Z"
}
````

***

### Data Fields Explanation

| Field Name | Format | Description |
|---|---|---|
| `job_title` | text | Name of the engineering vacancy. |
| `company_name` | text | Name of the hiring company. |
| `company_url` | link | Direct website URL of the employer. |
| `location` | text | Geographic location in Japan (prefecture or city ward). |
| `job_type` | text | Employment classification (typically full-time). |
| `seniority` | text | Seniority categorization (junior, intermediate, senior). |
| `remote_policy` | text | Remote work options (fully-remote, partially-remote, no-remote). |
| `japanese_required` | boolean | Set to `true` if conversational/business Japanese is needed. |
| `apply_from_abroad` | boolean | Set to `true` if visa sponsorship or overseas applications are permitted. |
| `salary_min` | number | Minimum annual salary bound in JPY. |
| `salary_max` | number | Maximum annual salary bound in JPY. |
| `salary_currency` | text | Always JPY. |
| `description` | text | Plain-text job requirements, responsibilities, and about us section. |
| `requirements` | array | Array of qualifications and skills extracted from the listing. |
| `tags` | array | Core technology and stack tags parsed from the job tags. |
| `posted_date` | text | Plain-text date when the listing was updated. |
| `job_url` | link | Canonical TokyoDev listing URL. |
| `scraped_at` | date | ISO 8601 scraping timestamp. |

***

### How Much Does It Cost to Scrape TokyoDev?

**$1.99 per 1,000 results.**

We offer the **best value at an affordable price**. Because the crawler parses sitemaps and loads detailed tech roles natively via server-side rendered HTML, there is zero browser overhead or expensive residential proxy data transfer fees. A full crawl of the entire board (~180+ jobs and ~230+ companies) runs in under a minute and costs under a few cents in platform compute, preserving your margin.

***

### Advanced Options & Tips

- **Targeted Crawls:** Paste specific TokyoDev detail/search URLs into the `searchUrls` option in your input to bypass the sitemap discovery entirely and scrape exact targets.
- **Low Concurrency:** Maintain a respectful crawl rate (`maxConcurrency: 10`) to ensure a friendly footprint on the site's server.

***

### FAQ (Frequently Asked Questions)

#### How does this scraper bypass bot protections?

TokyoDev uses Cloudflare managed challenges. However, its WAF posture is highly permissive to scrapers presenting realistic headers. Our scraper utilizes advanced browser-like header fingerprinting and request rotation, allowing it to execute safely on standard datacenter proxies without encountering blocks or JavaScript challenges.

#### Do I need a login or API Key?

No. All TokyoDev job and company profiles are fully public and require no authentication to scrape.

***

### Disclaimers & Support

This Actor is an independent web scraping tool and is not affiliated with, endorsed by, or sponsored by Paul McMahon, TokyoDev, tokyodev.com, or any of their subsidiaries or affiliates. All trademarks are the property of their respective owners.

The scraper accesses only public, unauthenticated job listings of the TokyoDev website, matching data the platform serves to any public user. Users are responsible for ensuring compliance with TokyoDev Terms of Service and local data regulations (e.g., Japan's APPI).

If you encounter issues or have custom requirements, please submit a report on our repository's **Issues** tab. For custom scraping or dataset services, contact the author's profile.

# Actor input Schema

## `scrapeMode` (type: `string`):

Select whether to extract job listings, company profiles, or both in the same dataset.

## `searchQuery` (type: `string`):

Perform free-text keyword matching across titles, tags, and descriptions (e.g., 'SRE', 'GenAI', 'Kubernetes').

## `minSalary` (type: `integer`):

Filter out jobs with maximum annual JPY salaries below this threshold (e.g. 8000000 for 8 Million JPY).

## `techTags` (type: `array`):

List of specific technology tags (e.g. \['TypeScript', 'Go', 'React']). If provided, only jobs matching at least one tag are saved.

## `remotePolicy` (type: `string`):

Filter results by remote work policy.

## `japaneseRequired` (type: `string`):

Filter results by Japanese language proficiency requirement.

## `applyFromAbroad` (type: `string`):

Filter listings based on candidate residency requirements and visa sponsorship.

## `searchUrls` (type: `array`):

Paste specific TokyoDev job links or company URLs to scrape. Bypasses sitemap discovery.

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

Maximum number of listings to extract during this crawl session.

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

Proxy settings for scraping. Standard Apify proxies work perfectly.

## Actor input object example

```json
{
  "scrapeMode": "jobs",
  "searchQuery": "",
  "minSalary": 0,
  "techTags": [],
  "remotePolicy": "",
  "japaneseRequired": "",
  "applyFromAbroad": "",
  "searchUrls": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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 = {
    "techTags": [],
    "searchUrls": [],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/tokyo-dev-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 = {
    "techTags": [],
    "searchUrls": [],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/tokyo-dev-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 '{
  "techTags": [],
  "searchUrls": [],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/tokyo-dev-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TokyoDev Scraper: Japan Tech Jobs & Companies",
        "description": "Scrape job listings and company profiles from TokyoDev.com. Extract job titles, companies, locations, remote policies, salary ranges, Japanese language requirements, visa sponsorship, and technology tags. Drop-in for HubSpot, Salesforce, and Airtable. $1.99 per 1,000 results.",
        "version": "1.0",
        "x-build-id": "U7N41fRWXs37uYNb7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~tokyo-dev-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-tokyo-dev-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/getascraper~tokyo-dev-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-tokyo-dev-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/getascraper~tokyo-dev-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-tokyo-dev-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",
                "required": [
                    "scrapeMode"
                ],
                "properties": {
                    "scrapeMode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "jobs",
                            "companies",
                            "both"
                        ],
                        "type": "string",
                        "description": "Select whether to extract job listings, company profiles, or both in the same dataset.",
                        "default": "jobs"
                    },
                    "searchQuery": {
                        "title": "Search Keyword",
                        "type": "string",
                        "description": "Perform free-text keyword matching across titles, tags, and descriptions (e.g., 'SRE', 'GenAI', 'Kubernetes').",
                        "default": ""
                    },
                    "minSalary": {
                        "title": "Minimum Salary (JPY)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Filter out jobs with maximum annual JPY salaries below this threshold (e.g. 8000000 for 8 Million JPY).",
                        "default": 0
                    },
                    "techTags": {
                        "title": "Target Tech Stack Tags",
                        "type": "array",
                        "description": "List of specific technology tags (e.g. ['TypeScript', 'Go', 'React']). If provided, only jobs matching at least one tag are saved.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remotePolicy": {
                        "title": "Remote Policy Filter",
                        "enum": [
                            "",
                            "fully-remote",
                            "partially-remote",
                            "no-remote"
                        ],
                        "type": "string",
                        "description": "Filter results by remote work policy.",
                        "default": ""
                    },
                    "japaneseRequired": {
                        "title": "Japanese Language Filter",
                        "enum": [
                            "",
                            "japanese-required",
                            "no-japanese-required"
                        ],
                        "type": "string",
                        "description": "Filter results by Japanese language proficiency requirement.",
                        "default": ""
                    },
                    "applyFromAbroad": {
                        "title": "Apply From Abroad Eligibility",
                        "enum": [
                            "",
                            "abroad-only",
                            "residents-only"
                        ],
                        "type": "string",
                        "description": "Filter listings based on candidate residency requirements and visa sponsorship.",
                        "default": ""
                    },
                    "searchUrls": {
                        "title": "Direct Start/Search URLs",
                        "type": "array",
                        "description": "Paste specific TokyoDev job links or company URLs to scrape. Bypasses sitemap discovery.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of listings to extract during this crawl session.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for scraping. Standard Apify proxies work perfectly.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
