# Jobicy Jobs Scraper (`automation-lab/jobicy-jobs-scraper`) Actor

Scrape public Jobicy remote job listings by keyword, category, job type, and region. Extract titles, companies, locations, dates, URLs, and descriptions.

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

## Pricing

Pay per event

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

## Jobicy Jobs Scraper

Extract public remote job listings from Jobicy for recruiting, job-board enrichment, market research, and automated hiring workflows.

### What does Jobicy Jobs Scraper do?

Jobicy Jobs Scraper collects public job listings from `jobicy.com` search, category, type, region, and individual job pages.

It is built for the server-rendered Jobicy pages that are visible without a login.

The actor can fetch list-page summaries and, when enabled, visit detail pages for full JSON-LD job data.

### Who is it for?

Recruiters can monitor fresh remote roles in target categories.

Talent sourcers can build lead lists of companies currently hiring remotely.

Job-board operators can enrich their own remote-job feeds.

Market researchers can track hiring demand by role, region, and company.

Career coaches can collect examples of remote openings for clients.

Automation teams can feed new jobs into alerts, CRMs, spreadsheets, or dashboards.

### Why use this actor?

Jobicy publishes remote listings across categories such as programming, marketing, design, writing, support, finance, and operations.

This actor turns those public pages into structured dataset rows.

You can run it once for research or schedule it to capture fresh listings over time.

### What data can it extract?

| Field | Description |
| --- | --- |
| `title` | Job title |
| `companyName` | Hiring company name |
| `companyUrl` | Company website when available |
| `companyLogoUrl` | Company logo URL when available |
| `location` | Listed location text |
| `remoteRegion` | Remote region or applicant location |
| `category` | Jobicy category when detected |
| `jobType` | Full time, contract, freelance, etc. |
| `salary` | Salary text when published |
| `postedAt` | Job posting date |
| `validThrough` | Expiration date from JobPosting JSON-LD |
| `summary` | Short list-page summary |
| `description` | Full description when detail fetching is enabled |
| `applyUrl` | Public apply/click-through URL fallback |
| `sourceUrl` | Jobicy job URL |
| `jobId` | Jobicy numeric job ID when present |
| `scrapedAt` | Timestamp for the extraction run |

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

The default pricing target is pay-per-event.

A small run starts with a low one-time start event and then charges per saved job listing.

The final Store pricing is set from measured cloud runs during QA preparation.

For typical use, start with `maxItems` around 25 and increase after confirming the query volume.

### How to use

1. Open the actor on Apify.
2. Add one or more Jobicy start URLs, keywords, categories, job types, or regions.
3. Keep `includeDescription` enabled if you need full descriptions.
4. Set `maxItems` to the number of jobs you want.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### Start URLs

Use any public Jobicy URL, for example:

- `https://jobicy.com/?s=marketing`
- `https://jobicy.com/categories/dev`
- `https://jobicy.com/categories/marketing`
- `https://jobicy.com/job-type/full-time`
- `https://jobicy.com/regions/europe`
- `https://jobicy.com/jobs/144914-onboarding-project-manager-europe`

#### Keywords

Add search terms such as:

- `marketing`
- `customer success`
- `typescript`
- `product manager`

#### Categories

Use Jobicy category slugs such as:

- `dev`
- `marketing`
- `design-multimedia`
- `copywriting`
- `customer-support`

#### Job types

Use Jobicy type slugs such as:

- `full-time`
- `part-time`
- `contract`
- `freelance`
- `internship`

#### Regions

Use Jobicy region slugs or names such as:

- `europe`
- `united-states`
- `worldwide`
- `canada`

### Output example

```json
{
  "title": "Onboarding Project Manager - Europe",
  "companyName": "Cloudbeds",
  "location": "Europe",
  "remoteRegion": "Europe",
  "jobType": "Full Time",
  "postedAt": "2026-05-27T11:43:13+00:00",
  "summary": "What Makes Us Unique...",
  "applyUrl": "https://jobicy.com/jobs/144914-onboarding-project-manager-europe",
  "sourceUrl": "https://jobicy.com/jobs/144914-onboarding-project-manager-europe"
}
````

### Tips for better results

Use multiple sources when you need more than the first page of one Jobicy section.

Combine category and keyword inputs to collect broader coverage.

Keep `includeDescription` enabled for complete job text.

Disable `includeDescription` when you only need a quick list-page snapshot.

Use a low `maxItems` for your first run.

### Integrations

Send dataset rows to Google Sheets for recruiter review.

Forward new jobs to Slack or Discord with Apify integrations.

Load rows into Airtable as a remote-job database.

Send company names into enrichment tools.

Use webhooks to trigger downstream processing after each run.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/jobicy-jobs-scraper').call({
  keywords: ['marketing'],
  maxItems: 25,
  includeDescription: true
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/jobicy-jobs-scraper').call(run_input={
    'keywords': ['marketing'],
    'maxItems': 25,
    'includeDescription': True,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~jobicy-jobs-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["marketing"],"maxItems":25,"includeDescription":true}'
```

### MCP usage

You can use this actor through Apify MCP so assistants can run Jobicy searches and read dataset results.

MCP tool URL:

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

Claude Code setup command:

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

Claude Desktop JSON configuration example:

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

Example prompts:

- "Use the Apify Jobicy MCP tool to find the latest marketing jobs and summarize hiring companies."
- "Run automation-lab/jobicy-jobs-scraper through MCP for dev and marketing categories, then save the CSV export link."
- "Compare remote product and support roles on Jobicy and return the top companies, locations, and source URLs."
- "Find 25 remote customer support jobs in Europe and return company names, job URLs, and posted dates."
- "Monitor Jobicy marketing jobs and draft a short Slack summary with the newest roles and apply links."

### Scheduling

Schedule the actor daily to collect new public Jobicy roles.

Use keywords or categories that map to your hiring niche.

Export each run or connect a webhook to deduplicate new URLs downstream.

### Legality

This actor extracts publicly available Jobicy pages.

You are responsible for using the data lawfully and respecting Jobicy terms, privacy rules, and applicable employment-data regulations.

Do not scrape personal data beyond what you are allowed to process.

### FAQ

#### Can I scrape Jobicy without an account?

Yes. This actor targets public Jobicy pages visible to anonymous visitors.

#### Does this actor use a browser?

No. It uses HTTP and HTML parsing for faster, lower-cost runs.

### Troubleshooting

#### Why did I get fewer jobs than requested?

Jobicy may show fewer public listings for a specific keyword, category, type, or region.

Add more sources or broader keywords.

#### Why is `applyUrl` the same as `sourceUrl`?

Some Jobicy listings expose the external apply flow through a guest/apply dialog rather than a static external URL.

When no public external URL is visible in HTML, the actor returns the public Jobicy job page as the apply URL.

#### Why is salary empty?

Many Jobicy jobs do not publish salary information.

The actor returns salary only when the page exposes it publicly.

### Related scrapers

Explore other automation-lab job and lead-generation scrapers on Apify:

- `https://apify.com/automation-lab/remote-jobs-scraper`
- `https://apify.com/automation-lab/linkedin-jobs-scraper`
- `https://apify.com/automation-lab/company-jobs-scraper`

### Changelog

Initial version extracts public Jobicy job listings from HTTP pages.

### Notes

This actor is not affiliated with Jobicy.

Jobicy is a trademark of its respective owner.

The actor is designed for public data collection and automation workflows.

### Version

Current development version: `0.1`.

### Support

If a run fails, include the run ID, input JSON, and expected Jobicy URL in your support request.

### Data quality checklist

Review titles.

Review company names.

Review location fields.

Review apply URLs.

Review source URLs.

Review posted dates.

Review descriptions.

### First-run recommendation

Start with this input:

```json
{
  "keywords": ["marketing"],
  "maxItems": 10,
  "includeDescription": true
}
```

# Actor input Schema

## `startUrls` (type: `array`):

Jobicy search, category, job type, region, or individual job URLs. Examples: https://jobicy.com/?s=marketing, https://jobicy.com/categories/dev, https://jobicy.com/jobs/144914-onboarding-project-manager-europe

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

Optional search terms. Each keyword is converted to a Jobicy search page.

## `categories` (type: `array`):

Optional Jobicy category slugs such as marketing, dev, design-multimedia, copywriting, customer-support, data.

## `jobTypes` (type: `array`):

Optional Jobicy job type slugs such as full-time, part-time, contract, internship, freelance.

## `regions` (type: `array`):

Optional Jobicy region slugs or names such as europe, united-states, worldwide, canada.

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

Maximum number of Jobicy job listings to save across all sources.

## `includeDescription` (type: `boolean`):

Fetch each Jobicy job detail page to extract full JSON-LD descriptions, company URLs, salary, valid-through dates, and apply URL fallback.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://jobicy.com/?s=marketing"
    }
  ],
  "keywords": [
    "marketing"
  ],
  "maxItems": 20,
  "includeDescription": true
}
```

# Actor output Schema

## `datasetUrl` (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 = {
    "startUrls": [
        {
            "url": "https://jobicy.com/?s=marketing"
        }
    ],
    "keywords": [
        "marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/jobicy-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 = {
    "startUrls": [{ "url": "https://jobicy.com/?s=marketing" }],
    "keywords": ["marketing"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/jobicy-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 '{
  "startUrls": [
    {
      "url": "https://jobicy.com/?s=marketing"
    }
  ],
  "keywords": [
    "marketing"
  ]
}' |
apify call automation-lab/jobicy-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobicy Jobs Scraper",
        "description": "Scrape public Jobicy remote job listings by keyword, category, job type, and region. Extract titles, companies, locations, dates, URLs, and descriptions.",
        "version": "0.1",
        "x-build-id": "ua230hI90Ph1UhZAy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~jobicy-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-jobicy-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~jobicy-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-jobicy-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~jobicy-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-jobicy-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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Jobicy search, category, job type, region, or individual job URLs. Examples: https://jobicy.com/?s=marketing, https://jobicy.com/categories/dev, https://jobicy.com/jobs/144914-onboarding-project-manager-europe",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Optional search terms. Each keyword is converted to a Jobicy search page.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categories": {
                        "title": "Category slugs",
                        "type": "array",
                        "description": "Optional Jobicy category slugs such as marketing, dev, design-multimedia, copywriting, customer-support, data.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTypes": {
                        "title": "Job type slugs",
                        "type": "array",
                        "description": "Optional Jobicy job type slugs such as full-time, part-time, contract, internship, freelance.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regions": {
                        "title": "Region slugs",
                        "type": "array",
                        "description": "Optional Jobicy region slugs or names such as europe, united-states, worldwide, canada.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Jobicy job listings to save across all sources.",
                        "default": 20
                    },
                    "includeDescription": {
                        "title": "Fetch full descriptions",
                        "type": "boolean",
                        "description": "Fetch each Jobicy job detail page to extract full JSON-LD descriptions, company URLs, salary, valid-through dates, and apply URL fallback.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
