# Workable Jobs Scraper (`fetch_cat/workable-jobs-scraper`) Actor

Scrape public Workable career boards by company slug or URL. Export job titles, locations, departments, workplace type, remote flags, dates, URLs, and optional descriptions.

- **URL**: https://apify.com/fetch\_cat/workable-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 job results

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

## Workable Jobs Scraper

Export public Workable career-board jobs by company slug or URL, including job titles, locations, departments, workplace type, remote flags, posting dates, job URLs, application URLs, and optional descriptions.

Use this Actor when you need a repeatable CSV, JSON, Excel, API, or AI-agent export of Workable-hosted job boards for recruiting intelligence, hiring-signal monitoring, sales research, or job-market analysis.

### What Does Workable Jobs Scraper Do?

Workable Jobs Scraper turns public Workable career pages into structured job listing rows.

- **Scrape by company slug**: use `recurly` from `https://apply.workable.com/recurly/`.
- **Scrape by URL**: paste Workable company career pages or job URLs.
- **Filter jobs**: use keyword, location, department, work type, and remote filters.
- **Collect job details**: export titles, locations, departments, workplace labels, remote flags, posting dates, job URLs, and Workable IDs.
- **Optionally include descriptions**: fetch job detail data for description, requirements, and benefits HTML.

### Input recipes

Use these examples when creating a task or running the Actor from the API.

| Goal | Input |
| --- | --- |
| Export all jobs for one Workable board | `{"companySlugs":["recurly"],"maxItems":20}` |
| Filter engineering jobs | `{"companySlugs":["recurly"],"query":"engineer","maxItems":50}` |
| Keep only remote roles | `{"companySlugs":["recurly"],"remote":true,"maxItems":50}` |
| Use Workable URLs | `{"startUrls":[{"url":"https://apply.workable.com/recurly/"}],"maxItems":20}` |
| Include full descriptions | `{"companySlugs":["recurly"],"includeDescription":true,"maxItems":20}` |

### Input Example

```json
{
  "companySlugs": ["recurly"],
  "query": "engineer",
  "remote": true,
  "maxItems": 20,
  "includeDescription": false
}
````

You can also paste Workable URLs:

```json
{
  "startUrls": [
    {
      "url": "https://apply.workable.com/recurly/"
    }
  ],
  "maxItems": 20
}
```

### Output Example

```json
{
  "companySlug": "recurly",
  "jobTitle": "Senior Software Engineer",
  "location": "United States",
  "departments": ["Engineering"],
  "workplace": "Remote",
  "remote": true,
  "publishedAt": "2026-07-01",
  "url": "https://apply.workable.com/recurly/j/example/",
  "jobId": 123456,
  "shortcode": "ABC123",
  "city": null,
  "region": null,
  "country": "United States",
  "workType": "Full-time",
  "applicationUrl": "https://apply.workable.com/recurly/j/example/apply/",
  "descriptionHtml": null
}
```

### Who Is It For?

| User | Use case |
| --- | --- |
| Recruiters | Monitor Workable-hosted boards for new roles and remote openings. |
| Sales teams | Find companies actively hiring by department, role, or region. |
| Market researchers | Track hiring activity across company lists and job categories. |
| Job-board operators | Export public Workable listings into a normalized dataset. |
| AI agents | Run Workable board checks through Apify API or MCP and summarize hiring signals. |

### Input Settings

| Setting | JSON key | What it does |
| --- | --- | --- |
| Company slugs | `companySlugs` | Workable company slugs from `apply.workable.com` URLs. |
| Start URLs | `startUrls` | Workable career page URLs or job URLs. The Actor extracts the company slug. |
| Search query | `query` | Optional keyword query such as `engineer`, `marketing`, or `sales`. |
| Locations | `locations` | Optional location filters such as `London`, `United States`, or `Remote`. |
| Departments | `departments` | Optional department filters such as `Engineering`, `Product`, or `Sales`. |
| Work types | `workTypes` | Optional Workable job type or workplace filters such as `full`, `hybrid`, or `remote`. |
| Remote only | `remote` | Use `true` for remote jobs only, `false` for non-remote only, or leave empty for both. |
| Maximum jobs | `maxItems` | Maximum job rows to save across all boards. |
| Include job descriptions | `includeDescription` | Fetch detail data with description, requirements, and benefits HTML. Slower but richer. |

### Output Fields

| Field | Description |
| --- | --- |
| `companySlug` | Workable company slug. |
| `jobTitle` | Job title. |
| `location`, `city`, `region`, `country`, `countryCode` | Location fields returned by Workable. |
| `departments` | Department labels. |
| `workplace`, `remote`, `workType` | Workplace and remote-work signals. |
| `publishedAt` | Posting date when available. |
| `url`, `applicationUrl` | Public job URL and application URL. |
| `jobId`, `shortcode` | Workable job identifiers. |
| `employmentType`, `language` | Additional job metadata when available. |
| `descriptionHtml`, `requirementsHtml`, `benefitsHtml` | Detail fields when `includeDescription` is enabled. |
| `raw` | Raw Workable job object for advanced users. |

### Pricing

This Actor uses pay-per-event pricing.

| Event | Price |
| --- | --- |
| Run started | `$0.005` per run |
| Job result | BRONZE tier: `$0.000031634` per saved job row, about `$0.032` per 1,000 rows |

The exact item price depends on your Apify plan tier. Runs that save fewer rows still include the one-time run-start event.

### Tips For Better Results

- **Use company slugs for clean inputs**: they are shorter and less fragile than copied URLs.
- **Start with a small `maxItems`**: confirm the board and filters before scheduling large runs.
- **Use `includeDescription` only when needed**: it adds richer fields but requests more detail data.
- **Leave filters empty for full board exports**: filters can exclude roles if company naming differs.
- **Check board availability**: not every company uses Workable or keeps old postings public.

### API Usage

Run the Actor with cURL:

```bash
curl "https://api.apify.com/v2/acts/fetch_cat~workable-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companySlugs":["recurly"],"query":"engineer","maxItems":20}'
```

Run from JavaScript:

```javascript
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/workable-jobs-scraper").call({
  companySlugs: ["recurly"],
  query: "engineer",
  maxItems: 20,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### MCP And AI Agents

This Actor works with the official Apify MCP server. Use the focused MCP URL when you want your AI tool to expose only this Actor:

```text
https://mcp.apify.com?tools=fetch_cat/workable-jobs-scraper
```

Example prompts:

- "Run Workable Jobs Scraper for this list of company slugs and summarize which companies are hiring engineers."
- "Export remote Workable jobs for these companies and return title, company, location, and application URL."
- "Check this Workable board every week and compare new jobs with the previous dataset."

### Limits And Notes

- The Actor extracts public Workable career-board data; it does not access private applicant systems.
- Filters depend on how each company configures its Workable board.
- Descriptions, requirements, and benefits are only included when `includeDescription` is enabled and available.
- Some older job URLs may be closed or redirected by Workable.

### FAQ

#### Can I scrape multiple Workable companies in one run?

Yes. Add multiple values to `companySlugs` or multiple URLs to `startUrls`.

#### Can I export Workable jobs to CSV or Excel?

Yes. Export the Apify dataset as CSV, Excel, JSON, XML, or RSS after the run.

#### Why did I get zero jobs?

Check that the company slug exists on `apply.workable.com`, remove strict filters, and try a small run without `query`, `locations`, or `departments`.

#### Why are descriptions missing?

Set `includeDescription` to `true`. Some boards or jobs still may not expose all detail fields.

#### Is this a Workable API alternative?

It can be used as an API-style export for public Workable career boards through Apify API, datasets, schedules, webhooks, and MCP.

### Related Actors

- [Dice Jobs Scraper](https://apify.com/fetch_cat/dice-jobs-scraper)
- [Greenhouse Job Board Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper)
- [Lever Jobs Scraper](https://apify.com/fetch_cat/lever-jobs-scraper)
- [Ashby Jobs Scraper](https://apify.com/fetch_cat/ashby-jobs-scraper)
- [SmartRecruiters Jobs Scraper](https://apify.com/fetch_cat/smartrecruiters-jobs-scraper)

### Support

If a run fails or output looks wrong, report the issue from the Actor page and include the Apify run ID or run URL, your input JSON, expected output, actual output, and one reproducible public Workable company URL or job URL.

### Changelog

#### 0.1

- Initial public release.

# Actor input Schema

## `companySlugs` (type: `array`):

Workable company slugs from apply.workable.com URLs, for example `recurly` from `https://apply.workable.com/recurly/`.

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

Workable career page URLs or job URLs. The actor extracts the company slug from each URL.

## `query` (type: `string`):

Optional keyword query sent to Workable, such as `engineer`, `marketing`, or `sales`.

## `locations` (type: `array`):

Optional location filters, for example `London`, `United States`, or `Remote`.

## `departments` (type: `array`):

Optional department filters, for example `Engineering`, `Product`, or `Sales`.

## `workTypes` (type: `array`):

Optional Workable job type or workplace filters, for example `full`, `hybrid`, or `remote`.

## `remote` (type: `boolean`):

Set to true to keep only jobs marked as remote, or false to keep only non-remote jobs. Leave empty for both.

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

Maximum number of job listings to save across all company boards.

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

Fetch each job detail page through Workable's public API and include description, requirements, and benefits HTML. This is slower but richer.

## Actor input object example

```json
{
  "companySlugs": [
    "recurly"
  ],
  "startUrls": [
    {
      "url": "https://apply.workable.com/recurly/"
    }
  ],
  "maxItems": 20,
  "includeDescription": 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 = {
    "companySlugs": [
        "recurly"
    ],
    "startUrls": [
        {
            "url": "https://apply.workable.com/recurly/"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/workable-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 = {
    "companySlugs": ["recurly"],
    "startUrls": [{ "url": "https://apply.workable.com/recurly/" }],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/workable-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 '{
  "companySlugs": [
    "recurly"
  ],
  "startUrls": [
    {
      "url": "https://apply.workable.com/recurly/"
    }
  ]
}' |
apify call fetch_cat/workable-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workable Jobs Scraper",
        "description": "Scrape public Workable career boards by company slug or URL. Export job titles, locations, departments, workplace type, remote flags, dates, URLs, and optional descriptions.",
        "version": "0.1",
        "x-build-id": "5PbEnWpMysbW04IfE"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~workable-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-workable-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/fetch_cat~workable-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-workable-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/fetch_cat~workable-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-workable-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": {
                    "companySlugs": {
                        "title": "Company slugs",
                        "type": "array",
                        "description": "Workable company slugs from apply.workable.com URLs, for example `recurly` from `https://apply.workable.com/recurly/`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Workable career page URLs or job URLs. The actor extracts the company slug from each URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Optional keyword query sent to Workable, such as `engineer`, `marketing`, or `sales`."
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional location filters, for example `London`, `United States`, or `Remote`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "departments": {
                        "title": "Departments",
                        "type": "array",
                        "description": "Optional department filters, for example `Engineering`, `Product`, or `Sales`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "workTypes": {
                        "title": "Work types",
                        "type": "array",
                        "description": "Optional Workable job type or workplace filters, for example `full`, `hybrid`, or `remote`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "remote": {
                        "title": "Remote only",
                        "type": "boolean",
                        "description": "Set to true to keep only jobs marked as remote, or false to keep only non-remote jobs. Leave empty for both."
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save across all company boards.",
                        "default": 20
                    },
                    "includeDescription": {
                        "title": "Include job descriptions",
                        "type": "boolean",
                        "description": "Fetch each job detail page through Workable's public API and include description, requirements, and benefits HTML. This is slower but richer.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
