# WorkersOnboard Scraper - Remote Work-From-Home Job Leads (`studio-amba/workersonboard-scraper`) Actor

Scrape remote and work-from-home job leads from WorkersOnboard's continuously updated job-log pages. Extract job titles, hiring companies, pay rates, and direct apply links. No login or cookies required.

- **URL**: https://apify.com/studio-amba/workersonboard-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.20 / 1,000 result scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

### What does WorkersOnboard Scraper do?

**WorkersOnboard Scraper** extracts remote and work-from-home job leads from [WorkersOnboard](https://www.workersonboard.com), a US-focused blog that curates new remote hiring opportunities in continuously updated job-log posts. Every result includes the job title, hiring company (where stated), pay rate (where stated), the date it was published on WorkersOnboard, and a direct external apply link straight to the employer's application page or ATS (iCIMS, Lever, Workday, and others).

Use it on the Apify platform to build a remote-jobs lead feed, monitor which companies are hiring work-from-home roles this week, or feed a job board / newsletter / alert system with fresh WFH openings — without manually re-reading a growing blog post every day.

### How to scrape WorkersOnboard data

1. Go to the WorkersOnboard Scraper on the Apify Store.
2. Click **Try for free** to open the actor in the Apify Console.
3. Leave the input empty to scrape both source pages (default), or pick just `weekly-jobs` or `friday-freebies`.
4. Set the maximum number of leads you want (default: 200 — most recent first).
5. Click **Start** and wait for the run to finish (usually under a minute — two page fetches, no browser rendering).
6. Download your data as JSON, CSV, Excel, or HTML from the Output tab.

### Why use WorkersOnboard Scraper?

- **Remote-hiring signal, not stale listicles** — WorkersOnboard's `weekly-jobs` and `friday-freebies` pages are the site's living, dated job logs (new sections keep getting appended), not the site's hundreds of static "top 10 ways to make money" articles. This actor targets exactly those two pages.
- **Real apply links, real companies** — Radiology Scheduler at Carenet Health, Customer Service at Elevance Health, Loan Service Specialist at QC Holdings, and dozens more per run, each linking straight to the employer's own careers page or ATS. Not affiliate redirects.
- **Lead generation** — See which companies are actively opening remote roles right now, for recruiting-tool sales, staffing outreach, or competitive hiring intelligence.
- **Job-seeker tooling** — Power a personal alert bot, a niche remote-jobs newsletter, or a WFH job aggregator without checking the blog by hand.
- **Zero anti-bot friction** — Plain WordPress, no Cloudflare JS challenge, no login. Fast, cheap, reliable runs.
- **Uncontested niche** — as of this writing there is no other Apify Store actor targeting this domain.

### About WorkersOnboard

WorkersOnboard is a US-based work-from-home content site. Most of its ~650 published pages are evergreen listicles and "how to make money from home" guides — **not** individual job postings, and this actor deliberately does not scrape that content. Its two job-log pages, however, work more like a manually curated hiring newsletter published as a blog post: a dated header ("Work from home Jobs for 7/21/2026") followed by a run of job title + description entries, with the oldest entries (back to March 2026 at the time of this build) still present further down the same page. See `docs/site-recon/workersonboard.md` for the full technical breakdown.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `sources` | Array | No | Which job-log page(s) to scrape: `weekly-jobs` and/or `friday-freebies`. Defaults to both. |
| `maxResults` | Integer | No | Maximum number of job leads to return, most recent first (default: 200, max: 5000). |
| `proxyConfiguration` | Object | No | Proxy settings. WorkersOnboard has no anti-bot protection — proxies are optional. |

### Output

Each result is one job/gig lead scraped from a WorkersOnboard job-log entry. You can download the dataset as JSON, CSV, Excel, or HTML.

#### Example output (real run, 2026-07-22)

```json
{
    "jobTitle": "Radiology Scheduler – Starts Aug. 13th",
    "company": "Carenet Health",
    "description": "Carenet Health is hiring reps to schedule, confirm, cancel, or reschedule radiology appointments. You will also confirm insurance information, document interactions, and other duties. Requires 6 months work from home customer service experience, strong problem-solving skills, Windows proficiency, and type 35 to 40 wpm. Pays $16 per hour with benefits.",
    "payText": "$16 per hour",
    "payAmount": 16,
    "payCurrency": "USD",
    "payPeriod": "hour",
    "remote": true,
    "postedAt": "2026-07-21T00:00:00.000Z",
    "sourceCategory": "weekly-jobs",
    "sourceUrl": "https://www.workersonboard.com/weekly-jobs/",
    "applyUrl": "https://careers-carenethealthcare.icims.com/jobs/5413/certified-medical-assistant-%7c-remote-%7c-%2417-hour-%7c-starts-08-20-2026/job",
    "url": "https://careers-carenethealthcare.icims.com/jobs/5413/certified-medical-assistant-%7c-remote-%7c-%2417-hour-%7c-starts-08-20-2026/job",
    "scrapedAt": "2026-07-22T14:51:02.368Z"
}
````

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `jobTitle` | String | Job or gig title as listed on WorkersOnboard |
| `company` | String or null | Hiring company name, extracted from the listing description — not stated for every entry (see Limitations) |
| `description` | String | Full listing description text as published on WorkersOnboard |
| `payText` | String or null | Pay rate as stated in the description (e.g. "$16 per hour") |
| `payAmount` | Number or null | Parsed numeric pay amount |
| `payCurrency` | String or null | Pay currency (USD — the site is US-focused) |
| `payPeriod` | String or null | Pay period: hour, day, week, month, task |
| `remote` | Boolean | Always `true` — WorkersOnboard exclusively lists remote / work-from-home opportunities |
| `postedAt` | String or null | Date the listing was published on WorkersOnboard (ISO 8601) |
| `sourceCategory` | String | Which job-log page the entry came from (`weekly-jobs` or `friday-freebies`) |
| `sourceUrl` | String | URL of the WorkersOnboard page this listing was scraped from |
| `applyUrl` | String | Direct external URL to apply for this job/gig |
| `url` | String | Alias of `applyUrl` |
| `scrapedAt` | String | ISO 8601 timestamp of when the data was collected |

### Cost estimate

This actor makes two plain HTTP requests (one per source page, no browser rendering) and parses the HTML server-side. A full run collecting 200+ leads typically uses well under **0.02 compute units** — a few seconds of a 1 GB run. This is one of the cheapest actor profiles in the fleet: no pagination, no per-item requests, no proxy dependency for correctness.

### Limitations

- **Not every entry names a company.** WorkersOnboard mixes true job listings ("Carenet Health is hiring...") with gig/reward-app entries phrased generically ("Get paid to shop for others..."). Company coverage runs roughly 85% on `weekly-jobs` and somewhat lower on `friday-freebies` — this reflects how the source content is written, not a parsing gap.
- **Pay rate is only stated for about half of entries.** When WorkersOnboard's description doesn't quote a rate, `payText`/`payAmount` are `null` rather than guessed.
- **No location filtering.** The site doesn't break out per-listing location data beyond "remote" — most roles are open to US-based remote workers, some are worldwide; check `description` for specifics.
- **History, not just "new."** Each run re-reads the full current job log, so early runs return the site's entire back catalogue (months of entries). Deduplicate on `applyUrl` between runs if you only want new leads, or use Apify's built-in dataset deduplication on scheduled runs.
- **Two source pages only.** WorkersOnboard has several other category pages (freelance gigs, focus groups, appointment setters, etc.) with only a handful of static entries each — not worth the added complexity of a third parsing path for a few extra rows. `weekly-jobs` and `friday-freebies` are the site's actively maintained job logs.

### Tips

- Schedule daily runs and diff against your last dataset (by `applyUrl`) to get only genuinely new leads.
- Use `sourceCategory` to separate the two feeds if you want to track their cadence independently — `weekly-jobs` updates far more often than `friday-freebies`.
- Filter on `payAmount` client-side after scraping if you only want listings above a certain hourly rate.

### Integrations

Connect WorkersOnboard Scraper with your existing tools and workflows:

- **Google Sheets** — Export new leads to a spreadsheet for a recruiting or side-income tracker.
- **Slack / Email** — Get notified when a new high-pay listing appears.
- **Zapier / Make** — Trigger workflows on new job leads in real time.
- **Custom API** — Access all results programmatically via the Apify API in JSON format.
- **Webhooks** — Fire actions in your own systems when new data lands.

### Related scrapers

- [NoFluffJobs Scraper](https://apify.com/studio-amba/nofluffjobs-scraper) — European tech jobs with mandatory salary ranges
- [TotalJobs Scraper](https://apify.com/studio-amba/totaljobs-scraper) — UK job board listings
- [IrishJobs Scraper](https://apify.com/studio-amba/irishjobs-scraper) — Ireland job board listings
- [JobSite Scraper](https://apify.com/studio-amba/jobsite-scraper) — UK job board listings
- [eJobs Scraper](https://apify.com/studio-amba/ejobs-scraper) — Romania job board listings

### FAQ and support

**Is this the same as scraping a job board?** Not exactly. WorkersOnboard doesn't run a job-listing database with per-job pages — it publishes hiring leads as dated entries inside two long-running blog posts. This actor parses that structure directly. See the Limitations section above for what that means for data completeness.

**Why are some `company` and `payText` fields empty?** Because WorkersOnboard's own description text doesn't always name a company or quote a rate — this happens most often for gig/reward-app entries ("take surveys," "watch videos"). The actor extracts what's actually stated; it doesn't guess.

**Do I need proxies?** No. WorkersOnboard has no anti-bot protection. Proxies are available as an optional input for larger-scale or more resilient scheduled runs.

**How often is the source updated?** WorkersOnboard adds new dated sections to `weekly-jobs` several times a week and to `friday-freebies` less frequently. Schedule the actor daily to catch new leads as they're published.

**I found a bug or have a feature request.** Open an issue in the Issues tab on the actor page.

# Actor input Schema

## `sources` (type: `array`):

Which WorkersOnboard job-log page(s) to scrape. 'weekly-jobs' is the largest and most frequently updated. Defaults to both.

## `maxResults` (type: `integer`):

Maximum number of job leads to return, most recent first.

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

Proxy settings. WorkersOnboard has no anti-bot protection -- proxies are optional but recommended for larger runs.

## Actor input object example

```json
{
  "sources": [
    "weekly-jobs",
    "friday-freebies"
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "sources": [
        "weekly-jobs",
        "friday-freebies"
    ],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/workersonboard-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 = {
    "sources": [
        "weekly-jobs",
        "friday-freebies",
    ],
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/workersonboard-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 '{
  "sources": [
    "weekly-jobs",
    "friday-freebies"
  ],
  "maxResults": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call studio-amba/workersonboard-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WorkersOnboard Scraper - Remote Work-From-Home Job Leads",
        "description": "Scrape remote and work-from-home job leads from WorkersOnboard's continuously updated job-log pages. Extract job titles, hiring companies, pay rates, and direct apply links. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "McK5uM2r4iNHw64Aa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~workersonboard-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-workersonboard-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/studio-amba~workersonboard-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-workersonboard-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/studio-amba~workersonboard-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-workersonboard-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": {
                    "sources": {
                        "title": "Source pages",
                        "type": "array",
                        "description": "Which WorkersOnboard job-log page(s) to scrape. 'weekly-jobs' is the largest and most frequently updated. Defaults to both.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "weekly-jobs",
                                "friday-freebies"
                            ],
                            "enumTitles": [
                                "Weekly Jobs (largest, updated most often)",
                                "Friday Freebies (smaller, complementary entries)"
                            ]
                        },
                        "default": [
                            "weekly-jobs",
                            "friday-freebies"
                        ]
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of job leads to return, most recent first.",
                        "default": 200
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. WorkersOnboard has no anti-bot protection -- proxies are optional but recommended for larger runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
