# Multi-ATS Jobs Scraper (Greenhouse, Lever, Ashby) (`devilscrapes/multi-ats-jobs-scraper`) Actor

Scrape job postings from Greenhouse, Lever, and Ashby in one run. Pass a list of company slugs and get a normalised dataset — title, location, department, URL, and description — across all three ATS platforms.

- **URL**: https://apify.com/devilscrapes/multi-ats-jobs-scraper.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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.

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

<div align="center">
  <img src=".actor/icon.svg" width="160" alt="Devil Scrapes mark" />

## Multi-ATS Jobs Scraper (Greenhouse, Lever, Ashby)

**$1.50 / 1 000 results** &nbsp;·&nbsp; pay only for results &nbsp;·&nbsp; no credit card to try

_We run the gauntlet across three ATS platforms so your jobs pipeline doesn't have to._

One Actor. Three job boards. A single normalised dataset row per posting — title, location, department, employment type, remote flag, and full description — ready to pipe into any downstream stack.

</div>

---

### 🎯 What this scrapes

Greenhouse, Lever, and Ashby together power the hiring pipelines of thousands of tech companies. Each platform exposes its own API shape and quirks. This Actor speaks all three natively: it queries the public job board APIs, normalises the fields into one consistent schema, and writes the results to a typed Apify dataset.

Pass a list of `{atsType, companySlug}` pairs — mix and match platforms in a single run. Get one row per job posting, every time.

Supported platforms:

| ATS | API endpoint style |
|---|---|
| **Greenhouse** | REST — `boards-api.greenhouse.io/v1/boards/{slug}/jobs` |
| **Lever** | REST — `api.lever.co/v0/postings/{slug}?mode=json` |
| **Ashby** | GraphQL — `jobs.ashbyhq.com/api/non-user-graphql` |

### 🔥 What we handle for you

- 🛡️ **Browser fingerprint rotation** — requests impersonate real browser TLS handshakes so the target sees a browser, not a bot.
- 🌐 **Residential proxy rotation** via Apify Proxy — fresh session and exit IP when upstream pushes back.
- 🔁 **Retries with exponential backoff** on `408 / 429 / 5xx` — up to 5 attempts, `Retry-After` honoured.
- 🧱 **Rate-limit-aware pacing** — we slow down rather than get banned; partial successes surface via a clear status message.
- 🧊 **Normalised, typed dataset rows** — Pydantic-validated, ISO-8601 timestamps, stable IDs across all three ATS platforms.
- 💰 **Pay-Per-Event pricing** — you pay only for job postings that land in your dataset.

### 💡 Use cases

- **Talent intelligence pipelines** — track hiring velocity at target companies; diff successive runs to spot new headcount or sudden freezes.
- **Competitive analysis** — monitor which roles a competitor is hiring for and in which locations.
- **Job aggregators** — power a niche job board (e.g. "remote fintech jobs") without scraping fragile HTML pages.
- **Recruitment automation** — feed a CRM or ATS of your own with normalised job data from multiple sources in one shot.
- **Market research** — identify which departments are growing fastest across an industry by counting roles by department field.
- **No-code workflows (n8n / Make / Zapier)** — connect via the Apify integration node; pipe new postings to a Slack channel or Google Sheet without writing code.

### ⚙️ How to use it

1. Click **Try for free** at the top of the page.
2. In the **Companies** field, enter a JSON array of `{atsType, companySlug}` objects — for example:
   ```json
   [
     {"atsType": "greenhouse", "companySlug": "stripe"},
     {"atsType": "lever", "companySlug": "vercel"},
     {"atsType": "ashby", "companySlug": "linear"}
   ]
````

3. Adjust **Max items per company** if you want a quick sample; leave at `0` for all postings.
4. Toggle **Include description** off if you only need metadata (faster, smaller dataset).
5. Click **Start**. Results stream into the run's dataset in real time.
6. Export from **Storage → Dataset** as JSON, CSV, or Excel — or fetch via the Apify API.

For no-code workflows: install the [Apify node for n8n](https://n8n.io/integrations/apify/) or the [Apify module for Make](https://www.make.com/en/integrations/apify), connect your Apify token, and point it at `DevilScrapes/multi-ats-jobs-scraper`.

### 📥 Input

| Field | Type | Required | Default | Notes |
|---|---|:--:|---|---|
| `companies` | `array` | **yes** | `[{"atsType":"greenhouse","companySlug":"stripe"},...]` | List of `{atsType, companySlug}` objects. Mix platforms freely. |
| `maxItemsPerCompany` | `integer` | no | `0` | Max postings per company. `0` = unlimited. |
| `includeDescription` | `boolean` | no | `true` | Fetch and store full job description text/HTML. |
| `proxyConfiguration` | `object` | no | `{"useApifyProxy": true}` | Apify Proxy config. We rotate sessions to absorb rate limits. |

**Example input:**

```json
{
  "companies": [
    {"atsType": "greenhouse", "companySlug": "stripe"},
    {"atsType": "lever", "companySlug": "vercel"},
    {"atsType": "ashby", "companySlug": "linear"}
  ],
  "maxItemsPerCompany": 50,
  "includeDescription": true,
  "proxyConfiguration": {"useApifyProxy": true}
}
```

### 📤 Output

One dataset row per job posting. All fields are present on every row; optional fields are `null` when not available from the ATS.

| Field | Type | Notes |
|---|---|---|
| `source_ats` | `string` | `"greenhouse"`, `"lever"`, or `"ashby"` |
| `company` | `string` | Company slug from your input |
| `job_id` | `string` | Posting ID from the ATS |
| `title` | `string` | Job title |
| `location` | `string \| null` | Location string from the ATS |
| `department` | `string \| null` | Department or team |
| `employment_type` | `string \| null` | e.g. `"Full-time"`, `"Contract"` |
| `remote` | `boolean \| null` | `true` = remote eligible; `null` = unknown |
| `url` | `string` | Canonical link to the job posting |
| `posted_at` | `string \| null` | ISO-8601 creation timestamp |
| `updated_at` | `string \| null` | ISO-8601 last-updated timestamp |
| `description` | `string \| null` | Full description (null if `includeDescription` is false) |

**Example output row:**

```json
{
  "source_ats": "greenhouse",
  "company": "stripe",
  "job_id": "4987321004",
  "title": "Software Engineer, Payments Infrastructure",
  "location": "San Francisco, CA",
  "department": "Engineering",
  "employment_type": "Full-time",
  "remote": false,
  "url": "https://boards.greenhouse.io/stripe/jobs/4987321004",
  "posted_at": "2026-05-10T14:32:00Z",
  "updated_at": "2026-06-01T09:11:00Z",
  "description": "<p>We're looking for an engineer to...</p>"
}
```

### 💰 Pricing

This Actor uses **Pay-Per-Event** pricing — you pay only for job postings written to your dataset.

| Event | Price |
|---|---|
| Actor start (one-off warm-up) | $0.005 |
| Per result emitted | $0.0015 |

**Effective rate: $1.50 / 1 000 results.**

A run that collects 500 job postings across three companies costs approximately $0.75 in result charges plus the $0.005 start fee. Empty runs (no matching postings) cost only the start fee.

### 🚧 Limitations

- **Company slugs must exist** on the chosen ATS. Passing an incorrect slug returns zero results for that company (logged as a warning, not a fatal error).
- **Ashby GraphQL schema** may evolve without notice — we track public API changes but cannot guarantee instant compatibility if Ashby deprecates fields.
- **Description field** can contain raw HTML. Strip tags on your end if plain text is required.
- **Pagination** is handled automatically, but very large boards (thousands of postings) may produce long run times at the default proxy tier.
- The Actor does **not** support authenticated ATS boards (private job listings require employer credentials).

### ❓ FAQ

**Can I scrape multiple companies in one run?**
Yes — that's the design. The `companies` array can hold as many `{atsType, companySlug}` pairs as you need. They run sequentially; use `maxItemsPerCompany` to cap each one.

**How do I find the correct company slug?**
For Greenhouse: visit `boards.greenhouse.io/<slug>`. For Lever: visit `jobs.lever.co/<slug>`. For Ashby: visit `jobs.ashbyhq.com/<slug>`. The slug is the path segment in each URL.

**Does this work with private / internal job boards?**
No. The Actor hits the same public API endpoints visible in a browser without authentication. Internal-only boards require employer credentials that this Actor does not support.

**Can I schedule this to run daily?**
Yes. Click **Schedule** in the Apify Console and set a cron expression. Each run produces a fresh snapshot — diff two runs to find new or closed postings.

**Can I export to Google Sheets or Airtable?**
Yes, via the Apify Console integrations or the [n8n](https://n8n.io/integrations/apify/) / [Make](https://www.make.com/en/integrations/apify/) connectors. Point them at `DevilScrapes/multi-ats-jobs-scraper` and map the output fields.

### 🤝 Your feedback

Found a company slug that returns wrong results? Hit an ATS quirk we don't handle? Open a support ticket or leave a review on the Apify Store listing — we read every one.

***

### Changelog

#### 0.1 — 2026-06-07

- Initial release. Greenhouse, Lever, and Ashby scrapers via public JSON APIs. Normalised typed dataset rows with Pydantic validation.

# Actor input Schema

## `companies` (type: `array`):

List of companies to scrape. Each entry must have <code>atsType</code> ("greenhouse", "lever", or "ashby") and <code>companySlug</code> (the slug used in the ATS board URL).

## `maxItemsPerCompany` (type: `integer`):

Maximum number of job postings to collect per company. Set to <code>0</code> (default) to collect all available postings.

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

When enabled, the full job description (HTML/text) is fetched and stored in the <code>description</code> field. Disable to reduce dataset size and run time.

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

Apify Proxy configuration. We rotate sessions and exit IPs to absorb rate limits across all three ATS platforms.

## Actor input object example

```json
{
  "companies": [
    {
      "atsType": "greenhouse",
      "companySlug": "stripe"
    },
    {
      "atsType": "lever",
      "companySlug": "lever"
    }
  ],
  "maxItemsPerCompany": 0,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

No description

## `datasetItemsCsv` (type: `string`):

No description

## `datasetView` (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 = {
    "companies": [
        {
            "atsType": "greenhouse",
            "companySlug": "stripe"
        },
        {
            "atsType": "lever",
            "companySlug": "lever"
        }
    ],
    "maxItemsPerCompany": 0,
    "includeDescription": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/multi-ats-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 = {
    "companies": [
        {
            "atsType": "greenhouse",
            "companySlug": "stripe",
        },
        {
            "atsType": "lever",
            "companySlug": "lever",
        },
    ],
    "maxItemsPerCompany": 0,
    "includeDescription": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/multi-ats-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 '{
  "companies": [
    {
      "atsType": "greenhouse",
      "companySlug": "stripe"
    },
    {
      "atsType": "lever",
      "companySlug": "lever"
    }
  ],
  "maxItemsPerCompany": 0,
  "includeDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call devilscrapes/multi-ats-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Multi-ATS Jobs Scraper (Greenhouse, Lever, Ashby)",
        "description": "Scrape job postings from Greenhouse, Lever, and Ashby in one run. Pass a list of company slugs and get a normalised dataset — title, location, department, URL, and description — across all three ATS platforms.",
        "version": "0.1",
        "x-build-id": "mxz38ngsqdJaJF8ZB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~multi-ats-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-multi-ats-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/devilscrapes~multi-ats-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-multi-ats-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/devilscrapes~multi-ats-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-multi-ats-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",
                "required": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies",
                        "type": "array",
                        "description": "List of companies to scrape. Each entry must have <code>atsType</code> (\"greenhouse\", \"lever\", or \"ashby\") and <code>companySlug</code> (the slug used in the ATS board URL)."
                    },
                    "maxItemsPerCompany": {
                        "title": "Max items per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of job postings to collect per company. Set to <code>0</code> (default) to collect all available postings.",
                        "default": 0
                    },
                    "includeDescription": {
                        "title": "Include job description",
                        "type": "boolean",
                        "description": "When enabled, the full job description (HTML/text) is fetched and stored in the <code>description</code> field. Disable to reduce dataset size and run time.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. We rotate sessions and exit IPs to absorb rate limits across all three ATS platforms.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```