# Craigslist Scraper — Listings, Prices & Contact Details (`junipr/craigslist-scraper`) Actor

Scrape Craigslist listings across jobs, housing, for sale, services, community, gigs. Two-phase scraping: search results + detail pages with images, geo-coords, attributes. Keyword/price filters. Export JSON/CSV.

- **URL**: https://apify.com/junipr/craigslist-scraper.md
- **Developed by:** [junipr](https://apify.com/junipr) (community)
- **Categories:** Lead generation, Other
- **Stats:** 13 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.30 / 1,000 listing scrapeds

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

## Craigslist Scraper

### What does Craigslist Scraper do?

Craigslist Scraper extracts listings from Craigslist across any city and category. It supports jobs, housing, for sale, services, community, and gigs sections. The actor scrapes both search result pages and individual listing detail pages to collect complete data including titles, prices, locations, full description text, images, structured attributes (bedrooms, compensation, make/model, etc.), geo-coordinates, and posting dates.

You can search by keyword, filter by price range, require images, sort results, and control how many pages to crawl. The two-phase approach (search pages first, then detail pages) gives you both breadth and depth, with the option to skip detail scraping for faster runs when you only need listing summaries.

### Features

- **Six categories** — Jobs, housing, for sale, services, community, and gigs
- **Any city** — Works with any Craigslist city subdomain (newyork, sfbay, chicago, losangeles, etc.)
- **Full detail scraping** — Optionally visits each listing page for complete body text, images, attributes, and geo-coordinates
- **Keyword search** — Filter listings by search terms within any category
- **Price filters** — Set minimum and maximum price ranges
- **Image filter** — Only return listings that include photos
- **Sort options** — Sort by date, price ascending, price descending, or relevance
- **Automatic pagination** — Crawls multiple search result pages to reach your target result count
- **Structured attributes** — Extracts category-specific fields like bedrooms, compensation, employment type, make/model
- **Geo-coordinates** — Captures latitude and longitude when listings include a map
- **Image URLs** — Collects all listing image URLs from detail pages
- **Configurable rate limiting** — Adjustable delay and concurrency to avoid Craigslist's aggressive rate limiting
- **Direct URL input** — Paste any Craigslist search URL directly instead of configuring city/category/query

### Input Configuration

```json
{
  "city": "newyork",
  "category": "jjj",
  "query": "software engineer",
  "maxResults": 100,
  "maxPages": 5,
  "sortBy": "date",
  "hasPic": false,
  "minPrice": 0,
  "maxPrice": 0,
  "scrapeDetails": true,
  "requestDelay": 1500,
  "maxConcurrency": 3
}
````

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchUrl` | string | `""` | Direct Craigslist search URL (overrides city/category if provided) |
| `city` | string | `"newyork"` | Craigslist city subdomain |
| `category` | string | `"jjj"` | Category code: `jjj` (jobs), `hhh` (housing), `sss` (for sale), `bbb` (services), `ccc` (community), `ggg` (gigs) |
| `query` | string | `""` | Keyword search term |
| `maxResults` | integer | `100` | Maximum listings to extract (1-5,000) |
| `maxPages` | integer | `5` | Maximum search result pages to crawl (1-50) |
| `sortBy` | string | `"date"` | Sort order: `date`, `priceasc`, `pricedsc`, or `rel` |
| `hasPic` | boolean | `false` | Only return listings with images |
| `minPrice` | integer | `0` | Minimum price filter (0 = no minimum) |
| `maxPrice` | integer | `0` | Maximum price filter (0 = no maximum) |
| `scrapeDetails` | boolean | `true` | Visit each listing's detail page for full data |
| `requestDelay` | integer | `1500` | Delay between requests in ms (minimum 500, 1500+ recommended) |
| `maxConcurrency` | integer | `3` | Maximum concurrent page requests (1-10, keep low) |

### Output Format

Each listing in the dataset looks like this:

```json
{
  "title": "Senior Software Engineer - Remote",
  "url": "https://newyork.craigslist.org/mnh/sof/d/senior-software-engineer/7812345678.html",
  "price": "$150,000",
  "location": "Manhattan",
  "postDate": "2026-03-10T14:30:00.000Z",
  "category": "jobs",
  "body": "We are looking for a senior software engineer to join our team...",
  "images": [
    "https://images.craigslist.org/00A0A_abc123_600x450.jpg"
  ],
  "attributes": {
    "employment_type": "full-time",
    "compensation": "$150,000/year"
  },
  "hasMap": true,
  "latitude": 40.7589,
  "longitude": -73.9851,
  "replyUrl": "https://newyork.craigslist.org/reply/mnh/sof/7812345678",
  "scrapedAt": "2026-03-11T12:00:00.000Z"
}
```

### Usage Examples / Use Cases

- **Job market research** — Analyze job postings by city to understand salary ranges, required skills, and hiring volume in specific markets
- **Real estate monitoring** — Track housing listings in target neighborhoods with price filters to spot deals or monitor rental trends
- **Marketplace analytics** — Collect for-sale listings to study pricing patterns, popular products, and geographic demand
- **Lead generation** — Find service providers and gig posters who may need your product or service
- **Academic research** — Build structured datasets of classified ad content for labor economics, housing studies, or marketplace analysis
- **Competitive intelligence** — Monitor competitor job postings to understand their hiring priorities and growth areas

### Proxy Requirements

Craigslist rate-limits aggressively and may block requests from datacenter IP addresses during extended scraping sessions. Proxy usage is optional but recommended for larger scraping runs.

- **Paid Apify plan users**: Datacenter proxy works for small runs (under 50 listings). For larger runs, switch to residential proxy in the Proxy Configuration input if you encounter blocks.
- **Free plan users**: The actor works without proxy for small batches. If you hit rate limits or blocks, increase `requestDelay` to 3000+ ms and reduce `maxConcurrency` to 1. For consistent large-scale scraping, provide your own residential proxy URL.
- Keep `requestDelay` at 1500ms or higher and `maxConcurrency` at 3 or lower to minimize rate limiting.

### FAQ

#### What is the difference between search URL and city/category inputs?

You can configure the search two ways. Either set `city` and `category` (and optionally `query`, price filters, etc.) and the actor builds the search URL for you, or paste a complete Craigslist search URL into the `searchUrl` field. If `searchUrl` is provided, it takes priority and the city/category fields are ignored. Use `searchUrl` when you have a pre-filtered search from the Craigslist website.

#### Should I enable detail scraping?

If you need full listing text, images, attributes, and geo-coordinates, keep `scrapeDetails` enabled (the default). If you only need titles, prices, locations, and posting dates, disable it for significantly faster runs since the actor skips visiting each individual listing page.

#### How do I avoid getting blocked by Craigslist?

Craigslist has aggressive rate limiting. Keep `requestDelay` at 1500ms or higher, set `maxConcurrency` to 1-3, and use a proxy. The actor rotates user agents automatically and includes realistic browser headers. For large scraping jobs (500+ listings), consider splitting across multiple runs.

#### What cities are supported?

Any Craigslist city subdomain works. Common examples: `newyork`, `losangeles`, `sfbay`, `chicago`, `seattle`, `boston`, `austin`, `denver`, `portland`, `miami`, `dallas`, `atlanta`. Check craigslist.org for the full list of city subdomains.

#### Can I scrape multiple cities in one run?

Not directly. Each run targets one city. To scrape multiple cities, run the actor multiple times with different `city` values, or use the `searchUrl` field with different city URLs in separate runs. You can schedule multiple runs to collect data from several cities automatically.

### Related Actors

- [Indeed Job Scraper](https://apify.com/junipr/indeed-job-scraper) — Scrape job listings from Indeed with detailed job descriptions and company info
- [Yellow Pages Scraper](https://apify.com/junipr/yellow-pages-scraper) — Extract business listings with contact details from Yellow Pages
- [Contact Info Scraper](https://apify.com/junipr/contact-info-scraper) — Extract emails, phones, and social links from any website
- [Google News Scraper](https://apify.com/junipr/google-news-scraper) — Collect news articles by topic or keyword
- [Trustpilot Reviews Scraper](https://apify.com/junipr/trustpilot-reviews-scraper) — Scrape business reviews and ratings from Trustpilot

# Actor input Schema

## `searchUrl` (type: `string`):

Direct Craigslist search URL. If provided, city and category fields are ignored. Example: https://newyork.craigslist.org/search/jjj?query=software+engineer

## `city` (type: `string`):

Craigslist city subdomain (e.g. 'newyork', 'losangeles', 'sfbay', 'chicago', 'seattle', 'boston', 'austin', 'denver').

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

Craigslist category code to search.

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

Optional keyword search term to filter listings (e.g. 'software engineer', '2 bedroom', 'mountain bike').

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

Maximum number of listings to extract.

## `maxPages` (type: `integer`):

Maximum number of search result pages to crawl. Craigslist shows up to 120 listings per page.

## `sortBy` (type: `string`):

How to sort search results.

## `hasPic` (type: `boolean`):

Only show listings with images.

## `minPrice` (type: `integer`):

Minimum price filter (leave empty for no minimum).

## `maxPrice` (type: `integer`):

Maximum price filter (leave empty or 0 for no maximum).

## `scrapeDetails` (type: `boolean`):

Visit each listing's detail page to get full body text, images, attributes, and geo-coordinates. Slower but provides complete data.

## `requestDelay` (type: `integer`):

Delay between requests in milliseconds. Craigslist rate limits aggressively — 1500ms+ recommended.

## `maxConcurrency` (type: `integer`):

Maximum number of pages to crawl simultaneously. Keep low (1-3) to avoid Craigslist rate limiting.

## Actor input object example

```json
{
  "searchUrl": "",
  "city": "newyork",
  "category": "jjj",
  "query": "",
  "maxResults": 100,
  "maxPages": 5,
  "sortBy": "date",
  "hasPic": false,
  "minPrice": 0,
  "maxPrice": 0,
  "scrapeDetails": true,
  "requestDelay": 1500,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped Craigslist listings with full details and metadata.

# 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 = {
    "searchUrl": "",
    "city": "newyork",
    "query": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("junipr/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 = {
    "searchUrl": "",
    "city": "newyork",
    "query": "",
}

# Run the Actor and wait for it to finish
run = client.actor("junipr/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 '{
  "searchUrl": "",
  "city": "newyork",
  "query": ""
}' |
apify call junipr/craigslist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Scraper — Listings, Prices & Contact Details",
        "description": "Scrape Craigslist listings across jobs, housing, for sale, services, community, gigs. Two-phase scraping: search results + detail pages with images, geo-coords, attributes. Keyword/price filters. Export JSON/CSV.",
        "version": "1.0",
        "x-build-id": "WySx1XQ9NeydkPzeS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/junipr~craigslist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-junipr-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/junipr~craigslist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-junipr-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/junipr~craigslist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-junipr-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",
                "properties": {
                    "searchUrl": {
                        "title": "Search URL",
                        "type": "string",
                        "description": "Direct Craigslist search URL. If provided, city and category fields are ignored. Example: https://newyork.craigslist.org/search/jjj?query=software+engineer",
                        "default": ""
                    },
                    "city": {
                        "title": "City",
                        "type": "string",
                        "description": "Craigslist city subdomain (e.g. 'newyork', 'losangeles', 'sfbay', 'chicago', 'seattle', 'boston', 'austin', 'denver').",
                        "default": "newyork"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "jjj",
                            "hhh",
                            "sss",
                            "bbb",
                            "ccc",
                            "ggg"
                        ],
                        "type": "string",
                        "description": "Craigslist category code to search.",
                        "default": "jjj"
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Optional keyword search term to filter listings (e.g. 'software engineer', '2 bedroom', 'mountain bike').",
                        "default": ""
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of listings to extract.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max Pages",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of search result pages to crawl. Craigslist shows up to 120 listings per page.",
                        "default": 5
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "date",
                            "priceasc",
                            "pricedsc",
                            "rel"
                        ],
                        "type": "string",
                        "description": "How to sort search results.",
                        "default": "date"
                    },
                    "hasPic": {
                        "title": "Has Picture",
                        "type": "boolean",
                        "description": "Only show listings with images.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Min Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum price filter (leave empty for no minimum).",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Max Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum price filter (leave empty or 0 for no maximum).",
                        "default": 0
                    },
                    "scrapeDetails": {
                        "title": "Scrape Detail Pages",
                        "type": "boolean",
                        "description": "Visit each listing's detail page to get full body text, images, attributes, and geo-coordinates. Slower but provides complete data.",
                        "default": true
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 500,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Delay between requests in milliseconds. Craigslist rate limits aggressively — 1500ms+ recommended.",
                        "default": 1500
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl simultaneously. Keep low (1-3) to avoid Craigslist rate limiting.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
