# The Better Craigslist Scraper (`betterscrapers/the-better-craigslist-scraper`) Actor

Affordable, efficient Craigslist scraper. Export listings, prices, locations and post dates from any Craigslist city and category via the public RSS feed. HTTP-only, low compute units per run.

- **URL**: https://apify.com/betterscrapers/the-better-craigslist-scraper.md
- **Developed by:** [Better Scrapers](https://apify.com/betterscrapers) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

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/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

## The Better Craigslist Scraper — Fast, Affordable Craigslist Listings & Price Scraper

Scrape Craigslist search results — **titles, prices and locations** — from any Craigslist city and category, without a browser. This **Craigslist scraper** reads the server-rendered (no-JavaScript) result list on the normal search page, so it is fast, lightweight and an **affordable** way to export **Craigslist listings** and **Craigslist prices** into JSON, CSV or Excel. A single request typically returns a few hundred listings.

Whether you are tracking local **for-sale deals**, monitoring **cars & trucks** prices, building a **used-goods price dataset**, or feeding listings into your own app, this actor gives you clean, structured **Craigslist data** at a low cost — typically **fewer compute units per run** than browser-based scrapers because it never launches a headless browser.

> Built for the **Better Scrapers** brand: do more with less compute.

### What it extracts

For every listing in the search feed, you get a normalized record with:

- **title** — the full listing title (HTML entities decoded, CDATA stripped)
- **url** — the absolute link to the Craigslist listing page
- **price** — the numeric price parsed out of the title (e.g. `8500`), or `null` for free/no-price listings
- **postedAt** — the exact post time as ISO-8601 UTC. Requires `getListingDetails` (the search page has no dates); otherwise `null`.
- **location** — the neighborhood/city Craigslist shows in trailing parentheses (e.g. `santa cruz`)
- **image** / **images** — the primary photo plus every photo on the posting. Requires `getListingDetails`; otherwise `null`.
- **description** — the posting body as plain text. Requires `getListingDetails`; otherwise absent.

### Features

- **HTTP-only, no browser** — uses `CheerioCrawler` against the search page, so runs are quick and cheap.
- **Any city, any category** — point it at `sfbay`, `newyork`, `losangeles`, `chicago`, or any Craigslist subdomain, with categories like `sss` (all for sale) or `cta` (cars & trucks).
- **Keyword search** — pass a `query` to filter listings server-side before they are ever downloaded.
- **Automatic pagination** — advances through the feed until your `maxItems` limit is reached or the results run out, with built-in de-duplication.
- **Price parsing built in** — the price is pulled straight out of the title and returned as a real number, ready for sorting and filtering.
- **Resilient parsing** — the core parser is pure, regex-based and dependency-free, so it keeps working even when markup shifts.
- **Cheap by design** — one small request per search, asset-free, and low memory needs.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `site` | string | *(required)* | Craigslist city subdomain, e.g. `sfbay`, `newyork`, `losangeles`, `chicago`. The part before `.craigslist.org`. |
| `category` | string | `"sss"` | Craigslist category code. Examples: `sss` (all for sale), `cta` (cars & trucks), `apa` (apartments/housing), `jjj` (jobs), `ggg` (gigs). |
| `query` | string | `""` | Optional keyword to search for, e.g. `mountain bike`. Leave blank for the whole category feed. |
| `maxItems` | integer | `100` | Maximum number of listings to collect. The scraper paginates until this limit or the feed is exhausted. |
| `getListingDetails` | boolean | `false` | Visit each posting for its **post date, all photos and description**. Costs one extra request per listing — leave off for the fastest, cheapest runs. |
| `proxyConfiguration` | object | `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }` | Craigslist rate-limits by IP reputation. Residential is the most reliable; datacenter may work but can return HTTP 403. |

#### Example input

```json
{
  "site": "sfbay",
  "category": "sss",
  "query": "mountain bike",
  "maxItems": 100,
  "proxyConfiguration": { "useApifyProxy": true }
}
````

### Output

Each listing is pushed to the dataset as one record. Example:

```json
{
  "title": "$8,500 2015 Honda Civic LX (santa cruz)",
  "url": "https://sfbay.craigslist.org/scz/cto/d/santa-cruz-2015-honda-civic/7712345678.html",
  "price": 8500,
  "postedAt": "2026-05-23T00:02:12.000Z",
  "location": "santa cruz",
  "image": "https://images.craigslist.org/00v0v_dAZwjpiARO8_0CI0t2_600x450.jpg",
  "images": ["https://images.craigslist.org/00v0v_dAZwjpiARO8_0CI0t2_600x450.jpg", "https://images.craigslist.org/00z0z_eX4PYBAOhnS_0CI0t2_600x450.jpg"],
  "description": "Diamondback Mountain Bike. Kids outgrew. Stored inside."
}
```

Export the full dataset as **JSON, CSV, Excel, XML or HTML** from the Apify console or API.

### Example use cases

- **Local deal hunting** — monitor `for sale` listings and get notified about under-priced items.
- **Used car price tracking** — scrape the `cta` (cars & trucks) category to build a **Craigslist car price** dataset.
- **Market & resale research** — analyze **Craigslist prices** by category and city over time.
- **Real-estate / apartment monitoring** — pull the `apa` housing feed for a city.
- **Lead generation & gigs** — collect `gigs` or `jobs` postings by keyword.
- **Price comparison apps** — feed structured **Craigslist data** into your own pricing or arbitrage tool.

### How it works

1. It builds the search URL for your city and category, e.g. `https://sfbay.craigslist.org/search/sss?query=mountain+bike` (Craigslist 301-redirects this to its canonical `www.craigslist.org/search/area/...` form, which the client follows).
2. `CheerioCrawler` fetches the feed over plain HTTP (no browser).
3. The pure `parseSearchHtml()` parser (in `src/parse.mjs`) extracts each `<li class="cl-static-search-result">`, decodes the title, and pulls out the price and location.
4. With `getListingDetails` on, each posting page is then fetched and `parseListingPage()` adds the post date (`<time datetime>`), every photo URL, and the description.
5. Records are de-duplicated by URL and pushed to the dataset.
6. The crawler follows the feed's pagination (`s=` offset) until `maxItems` is met or no new listings remain.

### Why it's efficient and affordable

- **No headless browser.** Browser scrapers spend most of their compute rendering pages. This actor only makes small HTTP requests to a text feed, so it uses **fewer compute units per run**.
- **One request per search.** The static result list returns hundreds of listings in a single response — no browser, no images, no scripts executed — so each run uses very few compute units. Detail fetching is opt-in, so you only pay the extra requests when you actually want dates and photos.
- **No rendering.** Only the raw HTML is fetched and parsed with plain string matching; no browser, CSS, JS or image bytes, which keeps memory and bandwidth low.
- **Server-side filtering.** Passing a `query` narrows results before download, so you pay only for the listings you actually want.

### FAQ

**Why are `postedAt` and `image` null?**\
Craigslist's search page lists only title, price, location and link — it carries no dates or photos, and the RSS feed that used to provide them now returns HTTP 403. Turn on **Get listing details** to visit each posting and fill in the post date, all photos and the description.

**Is scraping Craigslist with this actor reliable?**
It reads the server-rendered result list Craigslist ships for non-JavaScript clients, matching on its stable `cl-static-search-result` structure rather than on styling-dependent selectors.

**Which cities and categories are supported?**
Any Craigslist city subdomain (e.g. `sfbay`, `newyork`, `sandiego`) and any category code (e.g. `sss`, `cta`, `apa`, `jjj`, `ggg`).

**Why are some prices `null`?**
Not every listing has a price in its title (free items, jobs, gigs, service ads). When no price is present, `price` is `null` rather than a guess.

**How many listings can I get per run?**
Set `maxItems` to whatever you need. One search page returns roughly 300-360 listings, so requests above that will return fewer items than asked — narrow the query or use another category/city for more coverage.

**Do I need a proxy?**
Craigslist rate-limits aggressively by IP reputation. The residential proxy group is the most reliable choice; datacenter IPs often receive HTTP 403. Keep volumes modest either way.

### Legal & ethics

This actor reads **publicly visible** Craigslist search results. Note that Craigslist's Terms of Use prohibit automated access, and Craigslist has actively enforced this against commercial data collection. Use it responsibly and at your own risk: keep request volumes low, do not redistribute or republish the data, do not collect personal data, and comply with all applicable laws in your jurisdiction. You are responsible for how you use the data you collect.

# Actor input Schema

## `site` (type: `string`):

The Craigslist city subdomain to scrape, e.g. "sfbay", "newyork", "losangeles", "chicago". This is the part before ".craigslist.org".

## `category` (type: `string`):

Craigslist category code. Common values: "sss" (all for sale), "cta" (cars & trucks), "apa" (apartments/housing), "jjj" (jobs), "ggg" (gigs). Defaults to "sss".

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

Optional keyword to search for, e.g. "mountain bike", "honda civic", "standing desk". Leave blank to pull the whole category feed.

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

Maximum number of listings to collect. The scraper paginates the RSS feed until this limit is reached or the feed is exhausted.

## `getListingDetails` (type: `boolean`):

Visit each posting page to add postedAt, all photo URLs and the description. The search page alone has no date or photos, so leave this OFF for the fastest/cheapest runs and turn it ON when you need those fields. Costs one extra request per listing.

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

Craigslist rate-limits by IP reputation. The RESIDENTIAL group is the most reliable; datacenter IPs often get HTTP 403. Keep request volumes modest.

## Actor input object example

```json
{
  "site": "sfbay",
  "category": "sss",
  "query": "mountain bike",
  "maxItems": 100,
  "getListingDetails": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "site": "sfbay",
    "category": "sss",
    "query": "mountain bike",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("betterscrapers/the-better-craigslist-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 = {
    "site": "sfbay",
    "category": "sss",
    "query": "mountain bike",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("betterscrapers/the-better-craigslist-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 '{
  "site": "sfbay",
  "category": "sss",
  "query": "mountain bike",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call betterscrapers/the-better-craigslist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "The Better Craigslist Scraper",
        "description": "Affordable, efficient Craigslist scraper. Export listings, prices, locations and post dates from any Craigslist city and category via the public RSS feed. HTTP-only, low compute units per run.",
        "version": "0.1",
        "x-build-id": "9YzpeXAoK3HkNTtQF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/betterscrapers~the-better-craigslist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-betterscrapers-the-better-craigslist-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/betterscrapers~the-better-craigslist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-betterscrapers-the-better-craigslist-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/betterscrapers~the-better-craigslist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-betterscrapers-the-better-craigslist-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": [
                    "site"
                ],
                "properties": {
                    "site": {
                        "title": "Craigslist site (subdomain)",
                        "type": "string",
                        "description": "The Craigslist city subdomain to scrape, e.g. \"sfbay\", \"newyork\", \"losangeles\", \"chicago\". This is the part before \".craigslist.org\"."
                    },
                    "category": {
                        "title": "Category code",
                        "type": "string",
                        "description": "Craigslist category code. Common values: \"sss\" (all for sale), \"cta\" (cars & trucks), \"apa\" (apartments/housing), \"jjj\" (jobs), \"ggg\" (gigs). Defaults to \"sss\".",
                        "default": "sss"
                    },
                    "query": {
                        "title": "Search keyword (optional)",
                        "type": "string",
                        "description": "Optional keyword to search for, e.g. \"mountain bike\", \"honda civic\", \"standing desk\". Leave blank to pull the whole category feed."
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listings to collect. The scraper paginates the RSS feed until this limit is reached or the feed is exhausted.",
                        "default": 100
                    },
                    "getListingDetails": {
                        "title": "Get listing details (post date, photos, description)",
                        "type": "boolean",
                        "description": "Visit each posting page to add postedAt, all photo URLs and the description. The search page alone has no date or photos, so leave this OFF for the fastest/cheapest runs and turn it ON when you need those fields. Costs one extra request per listing.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Craigslist rate-limits by IP reputation. The RESIDENTIAL group is the most reliable; datacenter IPs often get HTTP 403. Keep request volumes modest.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```