# Craigslist Scraper - Fast Listings, Prices, Images & Contact (`harvexa/craigslist-scraper-fast-listings-prices-images-contact`) Actor

Scrape Craigslist listings by city, category, keyword, or URL. Get clean prices, images, descriptions, seller type, locations, category attributes, reply links, and structured data ready for automation.

- **URL**: https://apify.com/harvexa/craigslist-scraper-fast-listings-prices-images-contact.md
- **Developed by:** [Harvexa](https://apify.com/harvexa) (community)
- **Categories:** Jobs, Lead generation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.99 / 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.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

Extract clean, structured Craigslist listings from any supported city, category, search query, or direct listing URL. This Craigslist scraper is built for lead generation, marketplace research, price monitoring, inventory tracking, real estate research, vehicle analysis, and local classified data automation.

It returns ready-to-use data with titles, prices, descriptions, images, locations, seller type, category attributes, contact signals, timestamps, map links, reply links, and smart price intelligence.

### 🚀 What This Craigslist Scraper Does

- Scrape Craigslist search results by city, category, keyword, filters, and sorting.
- Scrape direct Craigslist listing URLs.
- Collect full listing details, descriptions, images, attributes, and location data.
- Extract prices with advanced price evidence: listed price, description price, secondary prices, and conflict detection.
- Detect seller type such as owner or dealer when available.
- Normalize category-specific fields for vehicles, phones, tools, furniture, electronics, housing, and more.
- Export clean structured data for CSV, Excel, Google Sheets, databases, CRMs, and automation workflows.

### ✨ Key Features

#### Smart Price Extraction

Craigslist listings often contain more than one number. This Actor separates the real listing price from extra numbers such as accessory prices, retail values, mileage, storage size, dates, counts, and specifications.

Useful price fields include:

- `price`
- `listedPrice`
- `descriptionPrice`
- `descriptionPrices`
- `secondaryPrices`
- `priceSource`
- `priceConflict`

This makes the output much safer for pricing tools, resale analysis, deal finding, and automated alerts.

#### Rich Listing Data

Each result can include:

- Listing title and URL
- Price and currency
- Description
- Category and subcategory
- City, state, and country
- Neighborhood and map coordinates
- Posted date, updated date, and post age
- Image URLs and image count
- Seller type and listing type
- Reply URL and map URL
- Phone numbers and emails when visible in the listing text
- Deleted or expired listing status
- Scrape timestamp

#### Category-Aware Attributes

The Actor extracts useful attributes depending on the listing type.

Examples:

- 🚗 Vehicles: year, mileage, fuel, transmission, drive, title status, color.
- 📱 Phones: brand, model, storage, network, carrier, mobile OS.
- 🛠️ Tools: make, model, voltage, power, phase.
- 🛋️ Furniture: material, dimensions, color, brand/model when available.
- 🏠 Housing: bedrooms, bathrooms, square feet, parking, pets.

### 📌 Popular Use Cases

- Craigslist lead generation
- Local marketplace monitoring
- Used car and vehicle research
- Real estate and rental listing collection
- Deal hunting and resale sourcing
- Price comparison and market analysis
- Competitor and inventory tracking
- Classified ads data extraction
- CRM enrichment and sales prospecting
- Automated alerts for new Craigslist listings

### 🧾 Input Options

You can run the scraper using guided search settings or direct URLs.

Common inputs:

- `region` - Craigslist city or market, such as `newyork`, `sfbay`, `losangeles`, `chicago`.
- `category` - Craigslist category slug, such as for sale, cars, housing, jobs, services, and more.
- `searchTerm` - Keyword or phrase to search for.
- `priceMin` and `priceMax` - Optional price range.
- `condition` - Optional item condition filter.
- `hasImage` - Return listings with images.
- `postedToday` - Return listings posted today.
- `sort` - Sort by newest or relevant results.
- `includeDetails` - Fetch full listing details.
- `detailConcurrency` - Control detail-page speed and cost.
- `maxResults` - Limit the number of results.
- `startUrls` - Scrape specific Craigslist search pages or listing URLs.

### 📤 Output Example

```json
{
  "title": "Iphone 12 mini 256gb unlocked",
  "price": 225,
  "listedPrice": 225,
  "descriptionPrice": 225,
  "priceSource": "page",
  "priceConflict": false,
  "categoryLabel": "For Sale",
  "subcategoryLabel": "Cell Phones",
  "city": "New York",
  "state": "NY",
  "country": "US",
  "condition": "Excellent",
  "categoryAttributes": {
    "brand": "Apple",
    "model": "iPhone 12 mini",
    "storage": "256GB",
    "network": "Unlocked"
  },
  "imageCount": 8,
  "sellerType": "owner",
  "postAgeDays": 1,
  "replyUrl": "https://newyork.craigslist.org/reply/...",
  "mapUrl": "https://www.openstreetmap.org/..."
}
````

### 🧠 Why Use This Actor?

Many Craigslist scrapers return only basic fields. This Actor is designed for real automation work, where clean prices, useful metadata, image counts, seller context, category attributes, and action URLs matter.

It is especially useful when you need data that can go directly into:

- Google Sheets
- Airtable
- Notion
- CRMs
- lead databases
- dashboards
- price monitoring systems
- resale and sourcing workflows
- AI agents and data pipelines

### ⚡ Performance & Cost

The Actor is optimized for efficient Craigslist data extraction. You can choose fast search-only mode or full detail mode depending on your data needs.

Recommended settings:

- Use `includeDetails=false` for fast, low-cost search monitoring.
- Use `includeDetails=true` when you need descriptions, attributes, full images, contact signals, reply URLs, and richer metadata.
- Use `maxResults` to control run size.
- Use `detailConcurrency` to balance speed and cost.

### ✅ Best Practices

- Start with a small `maxResults` test before running large jobs.
- Use direct `startUrls` when tracking specific searches or listings.
- Enable detail mode for serious lead generation or pricing analysis.
- Use `postedToday=true` for daily monitoring workflows.
- Export the dataset to CSV, JSON, Excel, or Google Sheets from Apify.

### ⚠️ Notes & Limitations

- Craigslist page structure and available fields can vary by city, category, and listing.
- Contact information is returned only when visible in the listing text.
- Reply URLs are generated when enough listing context is available.
- Some deleted, expired, or blocked listings may return partial data.
- Category-specific attributes are extracted when they can be detected confidently.

### 🔎 SEO Keywords

Craigslist scraper, Craigslist API, Craigslist data extraction, scrape Craigslist listings, Craigslist listings scraper, Craigslist price scraper, Craigslist real estate scraper, Craigslist car scraper, Craigslist lead generation, Craigslist marketplace data, Craigslist automation, Apify Craigslist scraper, classified ads scraper, local listings scraper.

# Actor input Schema

## `region` (type: `string`):

Choose the Craigslist city or metro area to monitor.

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

Select the top-level Craigslist section to collect.

## `searchTerm` (type: `string`):

Optional words that must match the Craigslist search.

## `priceMin` (type: `integer`):

Minimum listing price. Leave blank for no lower limit.

## `priceMax` (type: `integer`):

Maximum listing price. Leave blank for no upper limit.

## `condition` (type: `string`):

Applies to Craigslist categories that expose a condition filter.

## `hasImage` (type: `boolean`):

Skip postings that do not advertise an image.

## `postedToday` (type: `boolean`):

Restrict the search to Craigslist's posted-today results.

## `sort` (type: `string`):

Choose how Craigslist should order each search page.

## `includeDetails` (type: `boolean`):

Collect descriptions, full image galleries, coordinates, contacts, and category-specific attributes. Turn off for a faster summary-only dataset.

## `detailConcurrency` (type: `integer`):

Number of listing pages processed together. Five is balanced; lower this if a target market starts rate-limiting requests.

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

Maximum records across all sources. Use 0 for no user limit; the safety ceiling is 100,000.

## `startUrls` (type: `array`):

Optional search, category, or individual listing URLs. When supplied, these replace the guided market and listing-type selection above.

## Actor input object example

```json
{
  "region": "newyork",
  "category": "sss",
  "condition": "any",
  "hasImage": false,
  "postedToday": false,
  "sort": "date",
  "includeDetails": true,
  "detailConcurrency": 5,
  "maxResults": 200,
  "startUrls": []
}
```

# Actor output Schema

## `results` (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 = {
    "region": "newyork",
    "category": "sss",
    "condition": "any",
    "hasImage": false,
    "postedToday": false,
    "sort": "date",
    "includeDetails": true,
    "detailConcurrency": 5,
    "maxResults": 200,
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("harvexa/craigslist-scraper-fast-listings-prices-images-contact").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 = {
    "region": "newyork",
    "category": "sss",
    "condition": "any",
    "hasImage": False,
    "postedToday": False,
    "sort": "date",
    "includeDetails": True,
    "detailConcurrency": 5,
    "maxResults": 200,
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("harvexa/craigslist-scraper-fast-listings-prices-images-contact").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 '{
  "region": "newyork",
  "category": "sss",
  "condition": "any",
  "hasImage": false,
  "postedToday": false,
  "sort": "date",
  "includeDetails": true,
  "detailConcurrency": 5,
  "maxResults": 200,
  "startUrls": []
}' |
apify call harvexa/craigslist-scraper-fast-listings-prices-images-contact --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Scraper - Fast Listings, Prices, Images & Contact",
        "description": "Scrape Craigslist listings by city, category, keyword, or URL. Get clean prices, images, descriptions, seller type, locations, category attributes, reply links, and structured data ready for automation.",
        "version": "0.0",
        "x-build-id": "5lPwSS8IkbjH9d6c0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/harvexa~craigslist-scraper-fast-listings-prices-images-contact/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-harvexa-craigslist-scraper-fast-listings-prices-images-contact",
                "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/harvexa~craigslist-scraper-fast-listings-prices-images-contact/runs": {
            "post": {
                "operationId": "runs-sync-harvexa-craigslist-scraper-fast-listings-prices-images-contact",
                "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/harvexa~craigslist-scraper-fast-listings-prices-images-contact/run-sync": {
            "post": {
                "operationId": "run-sync-harvexa-craigslist-scraper-fast-listings-prices-images-contact",
                "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": {
                    "region": {
                        "title": "Market",
                        "enum": [
                            "newyork",
                            "losangeles",
                            "chicago",
                            "sfbay",
                            "seattle",
                            "boston",
                            "washingtondc",
                            "atlanta",
                            "dallas",
                            "houston",
                            "denver",
                            "philadelphia",
                            "miami",
                            "austin",
                            "sandiego",
                            "phoenix",
                            "portland",
                            "minneapolis",
                            "detroit",
                            "nashville",
                            "raleigh",
                            "charlotte",
                            "baltimore",
                            "stlouis",
                            "orlando",
                            "tampa",
                            "lasvegas",
                            "sacramento",
                            "hartford",
                            "columbus",
                            "indianapolis",
                            "cincinnati",
                            "cleveland",
                            "kansascity",
                            "milwaukee",
                            "sanantonio",
                            "pittsburgh",
                            "newhaven",
                            "providence",
                            "richmond",
                            "salem",
                            "saltlakecity",
                            "anchorage",
                            "honolulu",
                            "montreal",
                            "toronto",
                            "vancouver",
                            "calgary",
                            "ottawa",
                            "edmonton"
                        ],
                        "type": "string",
                        "description": "Choose the Craigslist city or metro area to monitor.",
                        "default": "newyork"
                    },
                    "category": {
                        "title": "Listing type",
                        "enum": [
                            "sss",
                            "cta",
                            "ela",
                            "fua",
                            "apa",
                            "roo",
                            "sub",
                            "jjj",
                            "ggg",
                            "bbb",
                            "ccc",
                            "rrr",
                            "eee"
                        ],
                        "type": "string",
                        "description": "Select the top-level Craigslist section to collect.",
                        "default": "sss"
                    },
                    "searchTerm": {
                        "title": "Search phrase",
                        "type": "string",
                        "description": "Optional words that must match the Craigslist search."
                    },
                    "priceMin": {
                        "title": "Price from",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price. Leave blank for no lower limit."
                    },
                    "priceMax": {
                        "title": "Price to",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price. Leave blank for no upper limit."
                    },
                    "condition": {
                        "title": "Item condition",
                        "enum": [
                            "any",
                            "new",
                            "like-new",
                            "excellent",
                            "good",
                            "fair",
                            "salvage"
                        ],
                        "type": "string",
                        "description": "Applies to Craigslist categories that expose a condition filter.",
                        "default": "any"
                    },
                    "hasImage": {
                        "title": "Only listings with photos",
                        "type": "boolean",
                        "description": "Skip postings that do not advertise an image.",
                        "default": false
                    },
                    "postedToday": {
                        "title": "Only newly posted listings",
                        "type": "boolean",
                        "description": "Restrict the search to Craigslist's posted-today results.",
                        "default": false
                    },
                    "sort": {
                        "title": "Result priority",
                        "enum": [
                            "date",
                            "rel",
                            "priceasc",
                            "pricedsc"
                        ],
                        "type": "string",
                        "description": "Choose how Craigslist should order each search page.",
                        "default": "date"
                    },
                    "includeDetails": {
                        "title": "Open every listing",
                        "type": "boolean",
                        "description": "Collect descriptions, full image galleries, coordinates, contacts, and category-specific attributes. Turn off for a faster summary-only dataset.",
                        "default": true
                    },
                    "detailConcurrency": {
                        "title": "Parallel detail requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of listing pages processed together. Five is balanced; lower this if a target market starts rate-limiting requests.",
                        "default": 5
                    },
                    "maxResults": {
                        "title": "Dataset size limit",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum records across all sources. Use 0 for no user limit; the safety ceiling is 100,000.",
                        "default": 200
                    },
                    "startUrls": {
                        "title": "Direct Craigslist sources",
                        "type": "array",
                        "description": "Optional search, category, or individual listing URLs. When supplied, these replace the guided market and listing-type selection above.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
