# Craigslist Scraper 🇺🇸 (all-in price per listing) (`tagadanar/craigslist-scraper`) Actor

Pull Craigslist listings into clean JSON in seconds: price, location, posting date, photos and a link to every post. Covers for sale, cars, housing, jobs, gigs and services across as many US cities as you want, one all-in price per listing, no key needed.

- **URL**: https://apify.com/tagadanar/craigslist-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** E-commerce, Real estate, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.05 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

Pull Craigslist listings into clean, flat JSON you can actually use: price, location, posting date, photos and a working link to every post. One run can cover for sale, housing, jobs, services and gigs, across as many cities as you list. No account, no API key, and the platform usage is included in the price so you get one predictable cost per listing.

Most Craigslist scrapers cover a single category or a single city and stop there. This one searches several cities at once, spans every section, filters to only the postings added in the last day or week (handy for monitoring), and can open each post to grab the description and any phone number or email the seller wrote into the ad.

### What you get

One record per listing, with these fields:

| Field | What it is |
| --- | --- |
| `id` | Craigslist posting ID |
| `title` | Listing title |
| `url` | Direct link to the posting |
| `price` | Price as a number (null when there is none) |
| `priceText` | Price exactly as shown, e.g. `$550` |
| `currency` | `USD` when a price is present |
| `city` | City subdomain, e.g. `sfbay` |
| `subArea` | Craigslist sub-area code, e.g. `eby` |
| `place` | Place or neighborhood, e.g. `Santa Clara` |
| `latitude`, `longitude` | Approximate coordinates |
| `postedAt` | Posting time, full ISO timestamp |
| `postedDate` | Posting date, `YYYY-MM-DD` |
| `categoryAbbr`, `categoryName` | Category code and its plain-English name |
| `section` | Section searched, e.g. `sss`, `hhh`, `cta` |
| `bedrooms`, `sqft` | Bedrooms and square feet on housing posts |
| `imageUrl` | First photo |
| `imageUrls`, `imageCount` | Every photo and how many |
| `dedupeId` | Craigslist's own de-dupe hash |
| `searchQuery` | The search term that returned it |
| `source`, `scrapedAt` | `craigslist.org` and the run time |

Turn on **Include contact details** to also get `description`, `attributes`, `phones`, `emails` and a `hasContact` flag for each post.

### Who uses it

- **Resellers and flippers** watch for underpriced gear across several metros at once, sorted newest first, filtered to posts with a photo.
- **Car dealers and buyers** track a make and model across cities, with owner-only or dealer-only filtering and the seller's phone straight from the ad.
- **Real-estate investors and agents** pull FSBO and for-rent posts with bedrooms, square feet and the poster's contact, filtered to a ZIP radius.
- **Recruiters and local-service pros** collect fresh jobs, gigs and services posts to prospect from, filtered to just today or the last few days.

### How to use it

Give it one or more cities (the subdomain you see in the address bar, like `sfbay` or `newyork`), pick a section, and add search terms if you want. Set **Posted since** to watch a search for new posts on a schedule. You are only charged for listings actually delivered.

#### Example: underpriced bikes with a photo, newest first

```json
{
  "cities": ["sfbay", "losangeles"],
  "category": "for-sale",
  "query": ["road bike", "gravel bike"],
  "priceFrom": 100,
  "priceTo": 800,
  "hasImage": true,
  "sort": "newest",
  "maxResults": 200
}
````

#### Example: a make and model across cities, from private owners, with phones

```json
{
  "cities": ["newyork", "chicago", "sfbay"],
  "category": "cars",
  "query": ["toyota tacoma"],
  "purveyor": "owner",
  "fetchContactInfo": true,
  "postedSince": "week",
  "maxResults": 100
}
```

#### Example: apartments near a ZIP, watched daily for new posts

```json
{
  "cities": ["losangeles"],
  "category": "apartments",
  "priceTo": 2500,
  "postal": "90028",
  "radiusMiles": 5,
  "postedSince": "today",
  "maxResults": 150
}
```

#### Example: paste a search straight from your browser

```json
{
  "searchUrls": ["https://sfbay.craigslist.org/search/sss?query=drum+set&hasPic=1"],
  "maxResults": 50
}
```

When `searchUrls` is set, the fields above it are ignored, so the run matches exactly what you filtered on the site.

### Pricing

You pay per listing returned, platform usage included in the price. No subscription.

| Event | Price |
| --- | --- |
| Actor start | $0.001 per run |
| Listing scraped | $1.50 per 1,000 |

The tiny start fee covers runs that return nothing; on any normal search it is noise next to the per-listing price.

### FAQ

**How do I scrape Craigslist without an API key?**
Just run this actor. There is no key and no login. Enter a city and a search term and you get structured results.

**Can I scrape multiple Craigslist cities at once?**
Yes. List several subdomains in `cities` and each is searched in turn, results merged into one dataset.

**How do I get seller phone numbers from Craigslist?**
Turn on **Include contact details**. The actor opens each post and reads any phone number or email the seller typed into the ad. Many do, though some rely on Craigslist's relay instead, so treat contact as best-effort.

**How do I monitor Craigslist for new listings?**
Set **Posted since** to Today or the last few days and schedule the run. Only posts inside that window are returned, so each run gives you just what is new.

**Can I scrape Craigslist apartments and housing with bedrooms and square feet?**
Yes. Use the Housing or Apartments section and each record carries `bedrooms` and `sqft` where the post lists them.

**Does it work for cars, jobs, gigs and services too?**
Yes. Pick the section you want. Cars and trucks, jobs, gigs, services, free stuff and community are all supported, alongside general for-sale.

**How many results can I get per search?**
Craigslist caps a single search at roughly 3,000 results. To go deeper, split the work: add price bands, use a ZIP radius, or search more cities.

**Is there a limit on how far the price or radius filters go?**
No. Set any price band and any radius in miles around a US ZIP. Leave them empty to search the whole city.

### Related actors

- [Kleinanzeigen Scraper](https://apify.com/tagadanar/kleinanzeigen-scraper) for Germany's largest classifieds site.
- [OLX Scraper](https://apify.com/tagadanar/olx-scraper) for OLX marketplaces across Europe.

***

Craigslist scraper, Craigslist API, scrape Craigslist listings, Craigslist for sale scraper, Craigslist cars scraper, Craigslist housing scraper, Craigslist apartments scraper, Craigslist jobs scraper, Craigslist gigs scraper, Craigslist services scraper, Craigslist lead generation, Craigslist phone numbers, FSBO leads, Craigslist monitor new listings, multi-city Craigslist scraper, Craigslist data export JSON.

# Actor input Schema

## `cities` (type: `array`):

One Craigslist city per entry, using the subdomain from the address bar, for example <code>sfbay</code>, <code>newyork</code>, <code>losangeles</code>, <code>chicago</code>. A full URL like <code>https://sfbay.craigslist.org</code> or a name like <code>San Francisco</code> also works. Each city is searched in turn.

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

Which part of Craigslist to search. Each choice covers all of that section's subcategories at once.

## `query` (type: `array`):

One search per entry, exactly what you would type into the Craigslist search box, e.g. <code>road bike</code>, <code>iphone 15</code>, <code>studio apartment</code>. Leave empty to browse the whole section.

## `priceFrom` (type: `integer`):

Lowest price to include, in dollars.

## `priceTo` (type: `integer`):

Highest price to include, in dollars.

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

Keep only postings that include at least one photo.

## `purveyor` (type: `string`):

Limit to private sellers (owner) or businesses (dealer). Applies where Craigslist offers the choice, mostly for-sale and cars.

## `postedSince` (type: `string`):

Keep only listings posted within this window. Set it to today or the last few days to watch a search for brand-new postings on a schedule.

## `postal` (type: `string`):

Search around a US ZIP code, e.g. <code>94103</code>. Combine with the radius below. Leave empty to search the whole city.

## `radiusMiles` (type: `integer`):

How far around the postal code to search, in miles. Ignored without a postal code.

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

Order of the results, same choices as on the site.

## `fetchContactInfo` (type: `boolean`):

Open each posting to add its full description and any phone number or email the seller wrote into the ad. Slower, and best paired with a tight search. Off by default.

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

Stop after this many listings across all searches. You are only charged for listings actually delivered.

## `searchUrls` (type: `array`):

Paste one or more craigslist.org search URLs straight from your browser, filters included, for example <code>https://sfbay.craigslist.org/search/sss?query=bike\&hasPic=1</code>. When set, the fields above are ignored.

## Actor input object example

```json
{
  "cities": [
    "sfbay"
  ],
  "category": "for-sale",
  "query": [
    "bike"
  ],
  "hasImage": false,
  "purveyor": "all",
  "postedSince": "any",
  "sort": "newest",
  "fetchContactInfo": false,
  "maxResults": 25
}
```

# Actor output Schema

## `listings` (type: `string`):

One item per listing in the default dataset.

# 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 = {
    "cities": [
        "sfbay"
    ],
    "query": [
        "bike"
    ],
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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 = {
    "cities": ["sfbay"],
    "query": ["bike"],
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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 '{
  "cities": [
    "sfbay"
  ],
  "query": [
    "bike"
  ],
  "maxResults": 25
}' |
apify call tagadanar/craigslist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Scraper 🇺🇸 (all-in price per listing)",
        "description": "Pull Craigslist listings into clean JSON in seconds: price, location, posting date, photos and a link to every post. Covers for sale, cars, housing, jobs, gigs and services across as many US cities as you want, one all-in price per listing, no key needed.",
        "version": "0.1",
        "x-build-id": "1xs4UzacZeb1fNV5H"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~craigslist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-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/tagadanar~craigslist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-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/tagadanar~craigslist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-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": {
                    "cities": {
                        "title": "Cities",
                        "minItems": 1,
                        "type": "array",
                        "description": "One Craigslist city per entry, using the subdomain from the address bar, for example <code>sfbay</code>, <code>newyork</code>, <code>losangeles</code>, <code>chicago</code>. A full URL like <code>https://sfbay.craigslist.org</code> or a name like <code>San Francisco</code> also works. Each city is searched in turn.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Section",
                        "enum": [
                            "for-sale",
                            "cars",
                            "free",
                            "housing",
                            "apartments",
                            "jobs",
                            "gigs",
                            "services",
                            "community"
                        ],
                        "type": "string",
                        "description": "Which part of Craigslist to search. Each choice covers all of that section's subcategories at once.",
                        "default": "for-sale"
                    },
                    "query": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "One search per entry, exactly what you would type into the Craigslist search box, e.g. <code>road bike</code>, <code>iphone 15</code>, <code>studio apartment</code>. Leave empty to browse the whole section.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "priceFrom": {
                        "title": "Price from (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lowest price to include, in dollars."
                    },
                    "priceTo": {
                        "title": "Price up to (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Highest price to include, in dollars."
                    },
                    "hasImage": {
                        "title": "Only listings with a photo",
                        "type": "boolean",
                        "description": "Keep only postings that include at least one photo.",
                        "default": false
                    },
                    "purveyor": {
                        "title": "Posted by",
                        "enum": [
                            "all",
                            "owner",
                            "dealer"
                        ],
                        "type": "string",
                        "description": "Limit to private sellers (owner) or businesses (dealer). Applies where Craigslist offers the choice, mostly for-sale and cars.",
                        "default": "all"
                    },
                    "postedSince": {
                        "title": "Posted since",
                        "enum": [
                            "any",
                            "today",
                            "3days",
                            "week",
                            "2weeks",
                            "month"
                        ],
                        "type": "string",
                        "description": "Keep only listings posted within this window. Set it to today or the last few days to watch a search for brand-new postings on a schedule.",
                        "default": "any"
                    },
                    "postal": {
                        "title": "Postal code",
                        "type": "string",
                        "description": "Search around a US ZIP code, e.g. <code>94103</code>. Combine with the radius below. Leave empty to search the whole city."
                    },
                    "radiusMiles": {
                        "title": "Radius (miles)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "How far around the postal code to search, in miles. Ignored without a postal code."
                    },
                    "sort": {
                        "title": "Sort by",
                        "enum": [
                            "newest",
                            "oldest",
                            "relevance",
                            "price-asc",
                            "price-desc",
                            "nearest"
                        ],
                        "type": "string",
                        "description": "Order of the results, same choices as on the site.",
                        "default": "newest"
                    },
                    "fetchContactInfo": {
                        "title": "Include contact details",
                        "type": "boolean",
                        "description": "Open each posting to add its full description and any phone number or email the seller wrote into the ad. Slower, and best paired with a tight search. Off by default.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after this many listings across all searches. You are only charged for listings actually delivered.",
                        "default": 100
                    },
                    "searchUrls": {
                        "title": "Search URLs (optional, replaces the fields above)",
                        "minItems": 1,
                        "type": "array",
                        "description": "Paste one or more craigslist.org search URLs straight from your browser, filters included, for example <code>https://sfbay.craigslist.org/search/sss?query=bike&hasPic=1</code>. When set, the fields above are ignored.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
