# Jobicy Remote Jobs Scraper - Search & All Current Remote Jobs (`lentic_clockss/jobicy-remote-jobs-scraper`) Actor

Search or filter current Jobicy remote jobs by keyword, geo, and industry, or export all current records with salary, level, location, apply links, and normalized fields.

- **URL**: https://apify.com/lentic\_clockss/jobicy-remote-jobs-scraper.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Jobicy Remote Jobs Scraper - Search & All Current Remote Jobs

**Search or filter Jobicy remote jobs by keyword, region (geo), and industry, or export every current remote job listing with salary, level, location, and application links as a clean Dataset.** This Actor calls the public Jobicy Remote Jobs API and returns normalized, deduplicated job records ready for spreadsheets, dashboards, recruitment pipelines, or AI agent workflows.

There are **no preset search keywords and no preset geo/industry filters**. Leave filters empty to collect all current Jobicy records returned by the API. Enter values only when you want Jobicy’s official title/description search or region/category filters.

### Why use this Jobicy Scraper?

- **Keyword search**: set `searchQuery` and the Actor queries Jobicy with the official `tag` search over job title and description.
- **Region filter**: set `geo` to a Jobicy geo slug such as `usa`, `emea`, or `apac`.
- **Industry filter**: set `industry` to a Jobicy industry slug such as `marketing` or `design-multimedia`.
- **All-current export by default**: empty input returns all current jobs from the Jobicy API response (API cap applies).
- **No hidden filters**: defaults contain no industry, geo, or tag filters.
- **Structured output**: title, company, salary, industry, level, location, posting date, job URL, and more.
- **Original raw data**: each row keeps the unmodified upstream API object in `raw`.
- **Search/filter provenance**: keyword rows include `sourceSearchQuery`/`searchRank`; geo/industry modes include `sourceGeo`/`sourceIndustry`.
- **No credentials needed**: public API only.
- **Attribution built in**: `source_url` and `attribution_url` make it easy to credit Jobicy.

### Tutorial

1. Click **Try for free** on this Actor page.
2. Optionally enter a keyword in `searchQuery` (for example `python`, `seo`, or `customer support`).
3. Optionally set `geo` (region slug) and/or `industry` (category slug).
4. To export all current jobs, leave `searchQuery`, `geo`, and `industry` empty.
5. Optionally set `maxItems` to cap output size. `0` means no client-side limit.
6. Click **Start** and wait for the run to finish.
7. Open the **Dataset** tab to download JSON, CSV, Excel, or JSONL.
8. Check `RUN_SUMMARY` in the key-value store for source counts, applied filters, and skipped records.

#### Example inputs

All-current mode:

```json
{}
````

Keyword search mode:

```json
{
  "searchQuery": "python",
  "maxItems": 10
}
```

Region + industry filter:

```json
{
  "geo": "usa",
  "industry": "marketing",
  "maxItems": 20
}
```

Combined keyword + filters:

```json
{
  "searchQuery": "seo",
  "geo": "usa",
  "industry": "marketing",
  "maxItems": 10
}
```

### Input and output examples

#### Input fields

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `searchQuery` | string | empty | Optional keyword or phrase. When set, Jobicy searches job title and description. |
| `geo` | string | empty | Optional Jobicy geo slug (for example `usa`, `emea`, `apac`, `australia`). Leave empty for all regions. |
| `industry` | string | empty | Optional Jobicy industry slug (for example `marketing`, `design-multimedia`, `supporting`). Leave empty for all industries. |
| `maxItems` | integer | `0` | Maximum matching job records to emit after normalize/dedupe. `0` means no client-side limit. Maximum `5000`. |

Unsupported aliases such as `query`, `keywords`, `tag`, `filters`, `jobGeo`, and `jobCategory` are rejected so runs do not silently change scope.

#### Output fields

| Field | Description |
| --- | --- |
| `id` | Jobicy job ID. |
| `record_type` | Always `job`. |
| `title` | Job title. |
| `company_name` | Hiring company. |
| `company_logo` | Logo URL when available. |
| `description`, `excerpt` | Job description and short excerpt when available. |
| `job_type` | Employment types (for example Full-Time). |
| `location` | Job geo; defaults to `remote` when missing. |
| `industry`, `tags` | Jobicy industry categories. |
| `level` | Experience level when available. |
| `salary`, `salary_min`, `salary_max`, `salary_currency`, `salary_period` | Salary metadata when supplied. |
| `published_at` | Publication timestamp. |
| `url`, `slug`, `source_url` | Jobicy links. |
| `source` | Always `jobicy`. |
| `sourceSearchQuery`, `searchRank` | Present in keyword search mode. |
| `sourceGeo`, `sourceIndustry` | Present when the corresponding input filter was set. |
| `attribution_url` | `https://jobicy.com`. |
| `crawled_at` | When this Actor collected the row. |
| `raw` | Original Jobicy API object. |

#### Run artifacts

| Artifact | When | Contents |
| --- | --- | --- |
| `INPUT_ECHO` | After valid input | Normalized scope, keyword, geo, industry, and limits. |
| `RUN_SUMMARY` | Successful run | Source, keyword, geo, industry, counts, applied filters, warnings. |
| `ERROR_SUMMARY` | Failed run | Error type and safe message. |

### Data source and search boundary

This Actor uses the public Jobicy endpoint `https://jobicy.com/api/v2/remote-jobs`.

- Default mode requests the current feed with `count=100` and **no** tag/geo/industry filters.
- Keyword mode adds Jobicy’s official `tag` query for title/description search.
- `geo` and `industry` are passed through as Jobicy’s official region and category filters (slug values).
- Discoverable values: locations via `?get=locations`, industries via `?get=industries`.
- Jobicy hard-caps the response size (currently 100 jobs). This is a current-feed snapshot, not a historical archive.
- Credit Jobicy with a direct link and keep application buttons pointing to the original job URL, as required by Jobicy’s API notice.

### Common geo and industry slugs

Use these **slug** values in `geo` / `industry`. Leave either field empty for no filter. Jobicy may add or rename slugs over time; the live catalogs are:

- locations: `https://jobicy.com/api/v2/remote-jobs?get=locations`
- industries: `https://jobicy.com/api/v2/remote-jobs?get=industries`

#### Common `geo` slugs

| Slug | Region |
| --- | --- |
| `usa` | USA |
| `uk` | UK |
| `canada` | Canada |
| `europe` | Europe |
| `emea` | EMEA |
| `apac` | APAC |
| `latam` | LATAM |
| `germany` | Germany |
| `france` | France |
| `netherlands` | Netherlands |
| `spain` | Spain |
| `ireland` | Ireland |
| `australia` | Australia |
| `singapore` | Singapore |
| `japan` | Japan |
| `philippines` | Philippines |
| `brazil` | Brazil |
| `mexico` | Mexico |
| `united-arab-emirates` | UAE |

> Tip: prefer the exact `geoSlug` from Jobicy’s locations feed. Regional buckets such as `emea`, `apac`, and `latam` are often useful when you do not want a single country.

#### `industry` slugs

| Slug | Industry |
| --- | --- |
| `admin-support` | Admin & Virtual Assistant |
| `business` | Business Development |
| `copywriting` | Content & Editorial |
| `design-multimedia` | Creative & Design |
| `supporting` | Customer Success |
| `cybersecurity` | Cybersecurity |
| `data-science` | Data Science & Analytics |
| `admin` | DevOps & Infrastructure |
| `e-commerce` | E-commerce |
| `education` | Education & E-learning |
| `accounting-finance` | Finance & Accounting |
| `healthcare` | Healthcare & Medical |
| `hr` | HR & Recruiting |
| `legal` | Legal & Compliance |
| `marketing` | Marketing & Sales |
| `management` | Product & Operations |
| `dev` | Programming |
| `project-management` | Project Management |
| `qa-testing` | QA & Testing |
| `seller` | Sales |
| `seo` | SEO |
| `smm` | Social Media Marketing |
| `engineering` | Software Engineering |
| `technical-support` | Technical Support |
| `translation-localization` | Translation & Localization |
| `video-audio-production` | Video & Audio Production |
| `web-app-design` | Web & App Design |

Example:

```json
{
  "geo": "usa",
  "industry": "engineering",
  "maxItems": 20
}
```

### Pricing

**Pay per event. No subscription.** Apify shows the effective event price before each run.

| Event | Price | When it is charged |
| --- | ---: | --- |
| `apify-actor-start` | **$0.005** | Automatically once when a normal Actor run starts. |
| `apify-default-dataset-item` | **$2.00 / 1,000** | Automatically for each item written to the default Dataset. |

Platform usage costs are paid by the user, as shown by Apify before a run. These are Apify synthetic events; the Actor does not manually issue duplicate charges in code.

### Live View and Standby endpoints

This Actor exposes an honest lightweight Live View service. Data collection stays in normal Actor runs.

| Endpoint | Purpose |
| --- | --- |
| `GET /` | Readiness and service information. |
| `GET /health` | Fast health check. |
| `GET /input-example` | Low-cost input compatible with the Actor schema. |
| `GET /openapi.json` | Deployed OpenAPI 3.x contract. |

### Connect from code

Actor ID: `lentic_clockss/jobicy-remote-jobs-scraper`

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("lentic_clockss/jobicy-remote-jobs-scraper").call(
    run_input={"searchQuery": "python", "maxItems": 10}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company_name"], item["source_url"])
```

### FAQ and support

**Does it search Jobicy by keyword?** Yes. Set `searchQuery`. The Actor uses Jobicy’s official title/description search and records `sourceSearchQuery` / `searchRank`.

**Can I filter by region or industry?** Yes. Set `geo` and/or `industry` to Jobicy slugs. The run records `sourceGeo` / `sourceIndustry` on output rows.

**Does default mode include all historical jobs?** No. Default mode exports all valid jobs in the current API response (API cap applies).

**Are there preset keywords or filters?** No. Defaults send no tag/geo/industry filters.

**What happens with zero matches?** When any of `searchQuery`, `geo`, or `industry` is set, the run can succeed with zero Dataset rows and a clear `RUN_SUMMARY`. Source failures write `ERROR_SUMMARY` and fail.

**Where can I report a problem?** Include the run ID, `RUN_SUMMARY` or `ERROR_SUMMARY`, and one example `source_url`. This Actor needs no credentials.

***

Explore more tools from [lentic\_clockss on Apify](https://apify.com/lentic_clockss).

# Actor input Schema

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

Optional keyword or phrase. When set, the Actor queries Jobicy with the official tag search over job title and description. Leave empty for no keyword filter.

## `geo` (type: `string`):

Optional Jobicy geo slug (for example usa, emea, apac, australia). Leave empty for all regions. Values come from Jobicy locations.

## `industry` (type: `string`):

Optional Jobicy industry slug (for example marketing, design-multimedia, supporting). Leave empty for all industries.

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

Set 0 to keep every valid matching Jobicy job record returned by the API. Use a positive number only when you deliberately want a smaller output.

## Actor input object example

```json
{
  "searchQuery": "python",
  "maxItems": 0
}
```

# Actor output Schema

## `results` (type: `string`):

All valid matching job records returned by the Jobicy API unless the user explicitly sets maxItems.

## `runSummary` (type: `string`):

Source, search query, counts for the source response, emitted records, duplicates, and malformed records.

## `inputEcho` (type: `string`):

Normalized non-secret input showing the actual collection or search scope.

## `errorSummary` (type: `string`):

Structured failure details when input validation or source acquisition fails.

# 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 = {
    "searchQuery": "python",
    "geo": "",
    "industry": "",
    "maxItems": 0
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/jobicy-remote-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 = {
    "searchQuery": "python",
    "geo": "",
    "industry": "",
    "maxItems": 0,
}

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/jobicy-remote-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 '{
  "searchQuery": "python",
  "geo": "",
  "industry": "",
  "maxItems": 0
}' |
apify call lentic_clockss/jobicy-remote-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobicy Remote Jobs Scraper - Search & All Current Remote Jobs",
        "description": "Search or filter current Jobicy remote jobs by keyword, geo, and industry, or export all current records with salary, level, location, apply links, and normalized fields.",
        "version": "0.1",
        "x-build-id": "zmLXETUyZCGpVjofr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~jobicy-remote-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-jobicy-remote-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/lentic_clockss~jobicy-remote-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-jobicy-remote-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/lentic_clockss~jobicy-remote-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-jobicy-remote-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": {
                    "searchQuery": {
                        "title": "Search keyword",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Optional keyword or phrase. When set, the Actor queries Jobicy with the official tag search over job title and description. Leave empty for no keyword filter."
                    },
                    "geo": {
                        "title": "Region / geo",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Optional Jobicy geo slug (for example usa, emea, apac, australia). Leave empty for all regions. Values come from Jobicy locations."
                    },
                    "industry": {
                        "title": "Industry / category",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Optional Jobicy industry slug (for example marketing, design-multimedia, supporting). Leave empty for all industries."
                    },
                    "maxItems": {
                        "title": "Maximum job records (optional)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Set 0 to keep every valid matching Jobicy job record returned by the API. Use a positive number only when you deliberately want a smaller output.",
                        "default": 0
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```