# Indeed Jobs Search Scraper (`jobsapi/indeed-jobs-search-scraper`) Actor

Scrape job listings from Indeed, the world's largest job search engine. Extract job titles, companies, locations, salaries, job types, and descriptions with advanced filtering for comprehensive job market analysis.

- **URL**: https://apify.com/jobsapi/indeed-jobs-search-scraper.md
- **Developed by:** [Jobs API](https://apify.com/jobsapi) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Indeed Jobs Search Scraper

The latest and most advanced Indeed Jobs Search Scraper. Our Indeed Jobs Search Scraper extracts real-time job postings at scale from all over the world. A new research tool built for recruitment, insights and HR.

### Features

- **Keyword search** — find jobs by keyword, search term, or role
- **Location filtering** — narrow results to specific cities, regions, or countries

### Use Cases

- **Job market research and salary benchmarking** — analyze salary ranges, benefits, and job requirements across US industries and regions
- **Recruitment pipeline automation** — source candidates at scale for high-volume hiring needs
- **Competitive intelligence on hiring activity** — track which companies are hiring, for what roles, and at what compensation levels
- **Labor market trend analysis** — monitor shifts in job types, remote work prevalence, and experience demands over time

### Sample Input

```json
{
  "keywords": "software engineer",
  "location": "New York, NY",
  "country": "www",
  "maxItems": 50,
  "maxPages": 5,
  "deepSearch": false,
  "datePosted": "7",
  "jobType": "fulltime",
  "experienceLevel": "",
  "remote": "",
  "sort": "relevance",
  "radius": "25",
  "headless": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "position": "web developer",
  "maxItemsPerSearch": 100,
  "parseCompanyDetails": false,
  "saveOnlyUniqueItems": true,
  "followApplyRedirects": false
}
````

### Sample Output

```json
{
  "jobKey": "abc123def456",
  "company": "Acme Corp",
  "location": "New York, NY",
  "salary": "$120,000 - $150,000/yr",
  "snippet": "We are looking for a senior software engineer to join our platform team...",
  "url": "https://www.indeed.com/viewjob?jk=abc123def456",
  "positionName": "Senior Software Engineer",
  "jobType": "fulltime",
  "rating": 4.2,
  "scrapedAt": "2026-06-24T12:00:00.000Z"
}
```

### Input

| Field | Type | Default | Required | Description |
|-------|------|---------|----------|-------------|
| `keywords` | string | `software engineer` | ✓ | Job search keywords (e.g., software engineer, data analyst, nurse) |
| `location` | string | ``|  | City, state, or zip code for job search (e.g., New York, NY) |
| `country` | string | `www` |  | Indeed country domain code. Use 'www' or 'us' for USA, 'uk' for UK, 'ca' for Canada, etc. |
| `maxItems` | integer | `50` |  | Maximum number of job listings to scrape. |
| `maxPages` | integer | `5` |  | Maximum number of search result pages to scrape (10 jobs per page). |
| `deepSearch` | boolean | `false` |  | When enabled, visits each job's detail page to extract full description, benefits, and hiring insights. |
| `datePosted` | string |`` |  | Filter by when the job was posted. |
| `jobType` | string | ``|  | Filter by job type. |
| `experienceLevel` | string |`` |  | Filter by experience level. |
| `remote` | string | ``|  | Filter for remote jobs only. |
| `sort` | string | `relevance` |  | Sort results by relevance or date. |
| `radius` | string |`` |  | Search radius in miles from the location. |
| `headless` | boolean | `true` |  | Run browser in headless mode (recommended for production). |
| `proxyConfiguration` | object | - |  | Proxy settings. Residential proxies recommended to avoid blocks. |
| `position` | string | - |  | Any combination of positions or keywords for search. |
| `maxItemsPerSearch` | integer | - |  | Maximum number of job listings to scrape for each keyword search and each Start URL. |
| `parseCompanyDetails` | boolean | `false` |  | If true, will also navigate to company page of each job posting. |
| `saveOnlyUniqueItems` | boolean | `true` |  | If true, only unique job listings will be scraped. |
| `followApplyRedirects` | boolean | `false` |  | If true, will follow redirects of Indeed's externalApplyLink and output the final one. |
| `startUrls` | array | - |  | List of URLs that will be scraped. Can be combined with keyword search. |
| `salaryMin` | integer | — |  | Minimum salary filter (in local currency). Only show jobs paying at least this amount. |
| `salaryMax` | integer | — |  | Maximum salary filter (in local currency). Only show jobs paying at most this amount. |
| `educationLevel` | string | — |  | Filter by minimum education level: High School, Associate Degree, Bachelor's, Master's, Doctorate. |

### Output

| Field | Description |
|-------|-------------|
| `jobKey` | Unique Indeed job identifier |
| `company` | Name of the hiring company |
| `location` | Job location (city, state, zip) |
| `salary` | Salary range if available |
| `benefits` | List of benefits (401k, insurance, etc.) |
| `snippet` | Short description snippet from search results |
| `url` | Direct URL to the job posting on Indeed |
| `detail` | Whether full detail was scraped |
| `deepScrapeStatus` | Status of deep scrape: success or failed |
| `detailData` | Full job detail (when deepSearch is enabled) |
| `scrapedAt` | ISO timestamp when the job was scraped |
| `searchPage` | Search result page number where the job was found |
| `positionName` | Position name |
| `jobType` | Job type |
| `rating` | Company rating |
| `reviewsCount` | Number of reviews |
| `companyInfo` | Company info object |

### Notes

- **Proxy**: Residential proxy is highly recommended
- **Rate limits**: Keep `maxItems` reasonable per run to avoid IP bans
- **Scheduling**: Use Apify Scheduler to run this actor on a recurring basis

# Actor input Schema

## `keywords` (type: `string`):

Job search keywords (e.g., software engineer, data analyst, nurse)

## `country` (type: `string`):

Indeed country domain code. Use 'www' or 'us' for USA, 'uk' for UK, 'ca' for Canada, 'in' for India, 'au' for Australia, etc.

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

Maximum number of job listings to scrape.

## `deepSearch` (type: `boolean`):

When enabled, visits each job's detail page to extract full description, benefits, and hiring insights.

## `experienceLevel` (type: `string`):

Filter by experience level.

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

Optionally, use Apify Proxy or custom HTTP proxy to avoid IP address-based blocking.

## `position` (type: `string`):

Any combination of positions or keywords for search. Can be used together with Start URLs - both will be scraped independently, each limited by Max job listings per search.

## `maxItemsPerSearch` (type: `integer`):

Maximum number of job listings to scrape for each keyword search and each Start URL. When both are used together, each is limited independently by this value.

## `parseCompanyDetails` (type: `boolean`):

If true, will also navigate to company page of each job posting, to scrape company info not available directly on job posting page.

## `salaryMin` (type: `integer`):

Minimum salary filter (in local currency). Only show jobs paying at least this amount.

## `salaryMax` (type: `integer`):

Maximum salary filter (in local currency). Only show jobs paying at most this amount.

## `remoteFilter` (type: `string`):

Filter by work location type.

## `datePosted` (type: `string`):

Filter by when the job was posted.

## `jobType` (type: `string`):

Filter by employment type.

## `educationLevel` (type: `string`):

Filter by minimum education level required.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "country": "www",
  "maxItems": 50,
  "deepSearch": false,
  "experienceLevel": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  },
  "position": "web developer",
  "maxItemsPerSearch": 100,
  "parseCompanyDetails": false,
  "remoteFilter": "",
  "datePosted": "",
  "jobType": "",
  "educationLevel": ""
}
```

# Actor output Schema

## `dataset` (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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    },
    "position": "web developer",
    "maxItemsPerSearch": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/indeed-jobs-search-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 = {
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
    "position": "web developer",
    "maxItemsPerSearch": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/indeed-jobs-search-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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  },
  "position": "web developer",
  "maxItemsPerSearch": 100
}' |
apify call jobsapi/indeed-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indeed Jobs Search Scraper",
        "description": "Scrape job listings from Indeed, the world's largest job search engine. Extract job titles, companies, locations, salaries, job types, and descriptions with advanced filtering for comprehensive job market analysis.",
        "version": "0.0",
        "x-build-id": "hzgtqepEPjxvv4z6l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jobsapi~indeed-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jobsapi-indeed-jobs-search-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/jobsapi~indeed-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jobsapi-indeed-jobs-search-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/jobsapi~indeed-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jobsapi-indeed-jobs-search-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": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search Keywords",
                        "type": "string",
                        "description": "Job search keywords (e.g., software engineer, data analyst, nurse)",
                        "default": "software engineer"
                    },
                    "country": {
                        "title": "Country Domain",
                        "type": "string",
                        "description": "Indeed country domain code. Use 'www' or 'us' for USA, 'uk' for UK, 'ca' for Canada, 'in' for India, 'au' for Australia, etc.",
                        "default": "www"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape.",
                        "default": 50
                    },
                    "deepSearch": {
                        "title": "Deep Search",
                        "type": "boolean",
                        "description": "When enabled, visits each job's detail page to extract full description, benefits, and hiring insights.",
                        "default": false
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "enum": [
                            "",
                            "entry_level",
                            "mid_level",
                            "senior_level"
                        ],
                        "type": "string",
                        "description": "Filter by experience level.",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optionally, use Apify Proxy or custom HTTP proxy to avoid IP address-based blocking.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    },
                    "position": {
                        "title": "Positions/keywords for search",
                        "type": "string",
                        "description": "Any combination of positions or keywords for search. Can be used together with Start URLs - both will be scraped independently, each limited by Max job listings per search."
                    },
                    "maxItemsPerSearch": {
                        "title": "Max job listings per search",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape for each keyword search and each Start URL. When both are used together, each is limited independently by this value."
                    },
                    "parseCompanyDetails": {
                        "title": "Scrape company details",
                        "type": "boolean",
                        "description": "If true, will also navigate to company page of each job posting, to scrape company info not available directly on job posting page.",
                        "default": false
                    },
                    "salaryMin": {
                        "title": "Minimum Salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum salary filter (in local currency). Only show jobs paying at least this amount."
                    },
                    "salaryMax": {
                        "title": "Maximum Salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum salary filter (in local currency). Only show jobs paying at most this amount."
                    },
                    "remoteFilter": {
                        "title": "Remote / On-site / Hybrid",
                        "enum": [
                            "",
                            "remote",
                            "hybrid",
                            "onsite"
                        ],
                        "type": "string",
                        "description": "Filter by work location type.",
                        "default": ""
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "",
                            "1",
                            "3",
                            "7",
                            "14",
                            "30"
                        ],
                        "type": "string",
                        "description": "Filter by when the job was posted.",
                        "default": ""
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "",
                            "fulltime",
                            "parttime",
                            "contract",
                            "temporary",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by employment type.",
                        "default": ""
                    },
                    "educationLevel": {
                        "title": "Education Level",
                        "enum": [
                            "",
                            "high_school",
                            "associate",
                            "bachelor",
                            "master",
                            "doctorate"
                        ],
                        "type": "string",
                        "description": "Filter by minimum education level required.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
