# Shine Jobs Scraper (`automation-lab/shine-jobs-scraper`) Actor

Scrape Shine.com job listings by keyword, location, or search URL. Export titles, companies, locations, salaries, skills, descriptions, and recruiter contacts.

- **URL**: https://apify.com/automation-lab/shine-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.06 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Shine Jobs Scraper

Export public job listings from Shine.com into clean datasets for recruiting research, market mapping, sales intelligence, and hiring analytics.

### What does Shine Jobs Scraper do?

Shine Jobs Scraper collects public job search results from [Shine.com](https://www.shine.com), one of India’s large recruitment websites.

It turns Shine search pages into structured rows that are ready for spreadsheets, BI tools, CRMs, enrichment workflows, and downstream automation.

You can scrape by keyword and location, or paste one or more Shine search URLs directly.

The actor reads the public server-rendered data available on Shine search pages and saves each job listing as one dataset item.

### Who is it for?

This actor is useful for several teams:

- 🧑‍💼 Recruiters tracking active hiring demand in India
- 📈 Talent intelligence teams mapping companies by role, skill, and location
- 🧲 Lead-generation teams finding companies currently hiring
- 🏢 Staffing agencies monitoring new openings across industries
- 🧪 Data analysts building job-market trend dashboards
- 🤖 Automation builders feeding Shine job data into workflows

### Why use this actor?

Shine search pages are designed for browsing, not bulk analysis.

This actor helps you avoid manual copying by extracting job data into a repeatable Apify dataset.

You can schedule it, call it from the API, export to CSV, or connect it to integrations.

### Data you can extract

The actor saves public fields when Shine includes them in the search result JSON.

| Field | Description |
| --- | --- |
| `jobId` | Shine job identifier |
| `title` | Job title |
| `companyName` | Employer or recruiter name |
| `companyId` | Shine company account ID when present |
| `industry` | Industry/category label |
| `location` | Original Shine location text |
| `locations` | Parsed location list |
| `salary` | Salary label shown by Shine |
| `experience` | Experience range |
| `jobType` | Job/employment type when present |
| `openings` | Number of vacancies when present |
| `postedAt` | Posted date string |
| `expiresAt` | Expiry date string |
| `skills` | Parsed skill keywords |
| `descriptionText` | Clean text job description |
| `descriptionHtml` | Optional raw HTML description |
| `recruiterPhone` | Public recruiter phone when present |
| `recruiterEmail` | Public recruiter email when present |
| `applyUrl` | External apply URL when present |
| `jobUrl` | Shine job detail URL |
| `searchUrl` | Search page used to find the job |
| `page` | Search result page number |
| `position` | Position in the collected result set |
| `totalResults` | Shine total count for the search |
| `source` | Always `shine.com` |
| `scrapedAt` | Collection timestamp |

### How much does it cost to scrape Shine jobs?

This actor uses pay-per-event pricing.

You pay a small start fee for each run and a per-result fee for each job listing saved.

For most searches, a small test run with 20 jobs is inexpensive and is a good way to confirm the output before running larger monitoring jobs.

Current pricing is a $0.005 run-start event plus tiered per-job pricing. The BRONZE per-job price is $0.0001 (about $0.10 per 1,000 saved jobs). Final Store pricing is shown on the Apify actor page before you start a run.

### How to use Shine Jobs Scraper

1. Open the actor on Apify.
2. Enter a job keyword such as `software engineer`.
3. Optionally enter a location such as `Bangalore`.
4. Set `Maximum jobs` to the number of listings you need.
5. Click **Start**.
6. Download results from the Dataset tab.

### Search by keyword and location

Use the `keyword` and `location` fields when you want the actor to build Shine search URLs for you.

Example:

```json
{
  "keyword": "data analyst",
  "location": "Mumbai",
  "maxItems": 50,
  "maxPages": 3
}
````

This searches Shine pages like:

```text
https://www.shine.com/job-search/data-analyst-jobs-in-mumbai
```

### Search by Shine URLs

Use `searchUrls` when you already have the exact Shine search pages you want to monitor.

Example:

```json
{
  "searchUrls": [
    { "url": "https://www.shine.com/job-search/software-engineer-jobs-in-bangalore" },
    { "url": "https://www.shine.com/job-search/sales-manager-jobs-in-delhi" }
  ],
  "maxItems": 100,
  "maxPages": 5
}
```

When `searchUrls` is provided, it overrides `keyword` and `location`.

### Input reference

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `keyword` | string | `software engineer` | Used when `searchUrls` is empty |
| `location` | string | `Bangalore` | Optional Shine location filter |
| `searchUrls` | array | example Shine URL | Direct URLs to scrape |
| `maxItems` | integer | `20` | Maximum saved jobs |
| `maxPages` | integer | `2` | Maximum pages per search URL |
| `includeDescriptionHtml` | boolean | `false` | Adds raw HTML description |

### Output example

```json
{
  "jobId": "18878393",
  "title": "Senior Software Developer (.NET)",
  "companyName": "Cynosure Corporate Solutions",
  "industry": "IT Services & Consulting",
  "location": "Chennai",
  "salary": "[Salary Hidden]",
  "experience": "6 to 8 Yrs",
  "skills": [".NET", "C#", "SQL"],
  "jobUrl": "https://www.shine.com/jobs/senior-software-developer-net/cynosure-corporate-solutions/18878393",
  "source": "shine.com"
}
```

Actual fields depend on what Shine exposes publicly for each listing.

### Tips for better results

- 🎯 Use specific keywords such as `java developer`, `business analyst`, or `digital marketing`.
- 📍 Add a location when you need city-level coverage.
- 🧪 Start with 25 jobs before running larger exports.
- 🔁 Schedule repeated runs to monitor newly posted jobs.
- 🧹 Keep `includeDescriptionHtml` disabled unless you need HTML formatting.

### Integrations

You can connect the dataset to many workflows:

- Send new jobs to Google Sheets for recruiting operations.
- Push hiring companies into a CRM for sales outreach.
- Feed job descriptions into an LLM classifier for skill extraction.
- Build dashboards in BigQuery, Snowflake, or Power BI.
- Trigger Slack alerts when target companies post new roles.

### API usage

Call the actor from Node.js:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/shine-jobs-scraper').call({
  keyword: 'software engineer',
  location: 'Bangalore',
  maxItems: 25
});

console.log(run.defaultDatasetId);
```

### Python API usage

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/shine-jobs-scraper').call(run_input={
    'keyword': 'data analyst',
    'location': 'Mumbai',
    'maxItems': 25,
})

print(run['defaultDatasetId'])
```

### cURL API usage

```bash
curl "https://api.apify.com/v2/acts/automation-lab~shine-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"software engineer","location":"Bangalore","maxItems":25}'
```

### MCP usage

Use this actor with Apify MCP tools in Claude Desktop or Claude Code.

MCP URL:

```text
https://mcp.apify.com?tools=automation-lab/shine-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-shine-jobs "https://mcp.apify.com?tools=automation-lab/shine-jobs-scraper"
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-shine-jobs": {
      "url": "https://mcp.apify.com?tools=automation-lab/shine-jobs-scraper"
    }
  }
}
```

Example prompts:

- “Run Shine Jobs Scraper for data analyst jobs in Mumbai and summarize top hiring companies.”
- “Find 50 Java developer openings in Bangalore and group them by required experience.”
- “Monitor Shine for sales manager jobs in Delhi and alert me when new companies appear.”

### Scheduling

You can schedule the actor daily or weekly from Apify.

A common setup is:

- Daily run for one keyword and one city
- `maxItems` set to 100 or 200
- Export dataset to Google Sheets or webhook
- Compare job IDs against previous runs to detect new listings

### Legality and responsible use

This actor extracts publicly available job listing data from Shine.com search pages.

You are responsible for using the data in a lawful way and respecting applicable terms, privacy rules, and employment-market regulations.

Do not use scraped contact data for spam or unlawful outreach.

### Troubleshooting

If a run returns fewer jobs than requested, the search may have fewer public listings than the requested limit, or Shine may have changed pagination for that query.

If you see no results, try a broader keyword such as `software engineer` or paste a Shine search URL that works in your browser.

If you need the original formatted description, enable `includeDescriptionHtml`.

### FAQ

#### Does this actor scrape private candidate profiles?

No. It scrapes public job listings only.

#### Does it require a Shine account?

No account is required for the public listing fields extracted by this actor.

#### Can I scrape multiple cities?

Yes. Add multiple Shine search URLs in `searchUrls`, one per city or query.

#### Why are some salaries hidden?

Shine sometimes displays `[Salary Hidden]`. The actor saves the value exactly as shown in the public data.

#### Are recruiter emails and phones always available?

No. They are saved only when Shine exposes them publicly for that listing.

### Related scrapers

Other automation-lab actors that may fit job-market workflows:

- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper)
- [Indeed Scraper](https://apify.com/automation-lab/indeed-scraper)
- [Company Website Scraper](https://apify.com/automation-lab/company-website-scraper)
- [Google Search Results Scraper](https://apify.com/automation-lab/google-search-results-scraper)

### Changelog

#### 0.1

Initial version with HTTP extraction from Shine search result pages, keyword/location search, direct URL mode, pagination, and structured job listing output.

# Actor input Schema

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

Job keyword to search on Shine, for example software developer, data analyst, or sales manager. Used when Search URLs are empty.

## `location` (type: `string`):

Optional Shine location filter, for example Bangalore, Delhi, Mumbai, Pune, or Hyderabad.

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

Optional Shine job-search URLs to scrape. If provided, these override keyword and location.

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

Maximum number of job listings to save across all search URLs.

## `maxPages` (type: `integer`):

Maximum Shine search result pages to visit for each search URL. Shine usually returns up to 20 jobs per page.

## `includeDescriptionHtml` (type: `boolean`):

Also save the raw HTML job description. Leave disabled for cleaner CSV/Excel exports.

## Actor input object example

```json
{
  "keyword": "software engineer",
  "location": "Bangalore",
  "searchUrls": [
    {
      "url": "https://www.shine.com/job-search/software-engineer-jobs-in-bangalore"
    }
  ],
  "maxItems": 20,
  "maxPages": 2,
  "includeDescriptionHtml": false
}
```

# Actor output Schema

## `overview` (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 = {
    "keyword": "software engineer",
    "location": "Bangalore",
    "searchUrls": [
        {
            "url": "https://www.shine.com/job-search/software-engineer-jobs-in-bangalore"
        }
    ],
    "maxItems": 20,
    "maxPages": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/shine-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": "software engineer",
    "location": "Bangalore",
    "searchUrls": [{ "url": "https://www.shine.com/job-search/software-engineer-jobs-in-bangalore" }],
    "maxItems": 20,
    "maxPages": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/shine-jobs-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 '{
  "keyword": "software engineer",
  "location": "Bangalore",
  "searchUrls": [
    {
      "url": "https://www.shine.com/job-search/software-engineer-jobs-in-bangalore"
    }
  ],
  "maxItems": 20,
  "maxPages": 2
}' |
apify call automation-lab/shine-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Shine Jobs Scraper",
        "description": "Scrape Shine.com job listings by keyword, location, or search URL. Export titles, companies, locations, salaries, skills, descriptions, and recruiter contacts.",
        "version": "0.1",
        "x-build-id": "Qe7sPwPhhxOdFFvra"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~shine-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-shine-jobs-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/automation-lab~shine-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-shine-jobs-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/automation-lab~shine-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-shine-jobs-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",
                "properties": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Job keyword to search on Shine, for example software developer, data analyst, or sales manager. Used when Search URLs are empty."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional Shine location filter, for example Bangalore, Delhi, Mumbai, Pune, or Hyderabad."
                    },
                    "searchUrls": {
                        "title": "Search URLs",
                        "type": "array",
                        "description": "Optional Shine job-search URLs to scrape. If provided, these override keyword and location.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save across all search URLs.",
                        "default": 20
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum Shine search result pages to visit for each search URL. Shine usually returns up to 20 jobs per page.",
                        "default": 2
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "Also save the raw HTML job description. Leave disabled for cleaner CSV/Excel exports.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```