# Craigslist Classifieds Scraper (`fetch_cat/craigslist-classifieds-scraper`) Actor

Scrape public Craigslist listings by city, category, keyword, price, and date. Export titles, prices, locations, images, descriptions, and attributes.

- **URL**: https://apify.com/fetch\_cat/craigslist-classifieds-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** E-commerce, Lead generation, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.03 / 1,000 item extracteds

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 Classifieds Scraper

Collect public Craigslist listings from city search pages, category pages, and keyword searches. Use it to monitor local prices, discover leads, compare housing or job supply, and export structured listing data to JSON, CSV, Excel, or your own workflow.

The actor accepts either ready-made Craigslist search URLs or simple city/category/query inputs. It can save lightweight search results only, or open each public listing page to add descriptions, attributes, images, timestamps, and map data when Craigslist exposes them.

### What does Craigslist Classifieds Scraper do?

Craigslist Classifieds Scraper turns public Craigslist pages into clean dataset rows. Instead of manually refreshing local search pages, copying titles, and pasting prices into spreadsheets, you can run an automated extraction with a repeatable input.

Typical outputs include listing title, URL, posting ID, price, currency, location, city/site, category, scrape timestamp, and optional detail-mode fields such as description, attributes, images, posted date, updated date, and map coordinates.

### Who is it for?

- 🏘️ **Real estate researchers** tracking apartment availability, rent ranges, and neighborhood supply.
- 🛒 **Resellers and marketplace teams** monitoring local prices for furniture, electronics, vehicles, and collectibles.
- 💼 **Lead generation teams** collecting public service, gig, and jobs listings for outreach workflows.
- 📊 **Market analysts** comparing classified activity across Craigslist cities and categories.
- 🧰 **Data operations teams** feeding local listings into dashboards, databases, alerts, and enrichment pipelines.

### Why use it?

Craigslist is local, fragmented, and constantly changing. A saved dataset lets you compare cities, watch price movement, and trigger downstream automations without manually checking dozens of tabs.

This actor is useful when you need:

- recurring local-market monitoring,
- structured exports for spreadsheets or BI tools,
- repeatable query inputs,
- optional listing details,
- dataset-ready records with stable field names.

### What data can you extract?

| Field | Description |
| --- | --- |
| `title` | Listing headline from search or detail page |
| `url` | Public Craigslist listing URL |
| `id` | Numeric Craigslist posting ID parsed from the URL |
| `price` | Numeric price when visible |
| `currency` | Currency code when detected, such as `USD` |
| `location` | Location text shown on the result card |
| `cityOrSite` | Craigslist city/site subdomain, such as `sfbay` |
| `category` | Category code inferred from the search URL |
| `postedAt` | Listing posted timestamp when detail mode finds it |
| `updatedAt` | Listing updated timestamp when available |
| `description` | Public listing body in detail mode |
| `attributes` | Listing attributes such as condition, make, size, bedrooms, or compensation when present |
| `imageUrls` | Public Craigslist image URLs when present |
| `latitude` | Latitude when Craigslist exposes map data |
| `longitude` | Longitude when Craigslist exposes map data |
| `sellerContactAvailable` | Whether a public reply control is present |
| `scrapedAt` | Timestamp when the item was saved |

### How much does it cost to scrape Craigslist classifieds?

This actor uses pay-per-event pricing. You pay a small run-start event plus one result event for every dataset item saved. The exact live price is shown on the Apify Store actor page before you run it.

For a first test, use the prefilled input with `maxItems` set to 10. Increase the limit once the output matches your workflow.

### Quick start

1. Open the actor on Apify.
2. Keep the prefilled Craigslist search URL or enter your own.
3. Set `maxItems` to a small number for the first run.
4. Enable `includeDetails` if you need descriptions, attributes, images, and timestamps.
5. Click **Start**.
6. Download results from the default dataset as JSON, CSV, Excel, XML, or RSS.

### Input options

You can provide source pages in two ways.

#### Option 1: Craigslist search URLs

Use `startUrls` when you already have Craigslist URLs from your browser.

```json
{
  "startUrls": [
    { "url": "https://sfbay.craigslist.org/search/sss?query=desk" }
  ],
  "maxItems": 25,
  "includeDetails": true
}
````

#### Option 2: City, category, and query

Use the guided fields to generate a URL.

```json
{
  "cityOrSite": "sfbay",
  "category": "sss",
  "query": "desk",
  "maxItems": 25,
  "includeDetails": false
}
```

### Common Craigslist category codes

| Code | Meaning |
| --- | --- |
| `sss` | all for sale |
| `fuo` | furniture |
| `apa` | apartments / housing |
| `jjj` | jobs |
| `ggg` | gigs |
| `bbb` | services |
| `gms` | garage sales |
| `ccc` | community |

You can use any public Craigslist category code that works in a normal Craigslist search URL.

### Filtering tips

- Set `minPrice` and `maxPrice` for categories where Craigslist supports price filters.
- Set `hasImage` to keep searches focused on listings with photos.
- Use `postedWithin` to focus on today's posts when freshness matters.
- Use `sort` to switch between newest, relevance, and price order where Craigslist supports it.
- Keep `maxItems` low for exploratory runs.
- Use separate runs for different cities if you want clean city-by-city exports.

### Output example

```json
{
  "title": "Standup desk",
  "url": "https://sfbay.craigslist.org/sfc/fuo/d/example/1234567890.html",
  "id": "1234567890",
  "price": 150,
  "currency": "USD",
  "location": "san francisco",
  "cityOrSite": "sfbay",
  "category": "sss",
  "postedAt": "2026-06-14T08:12:00-0700",
  "updatedAt": "2026-06-14T09:00:00-0700",
  "description": "Adjustable standing desk in good condition.",
  "attributes": { "condition": "good" },
  "imageUrls": ["https://images.craigslist.org/example.jpg"],
  "latitude": 37.77,
  "longitude": -122.42,
  "sellerContactAvailable": true,
  "scrapedAt": "2026-06-14T12:00:00.000Z"
}
```

### Search-only mode vs detail mode

Search-only mode is faster and cheaper because it reads the listing cards already visible on search pages. It is best for title, URL, price, and location monitoring.

Detail mode opens each listing page. Use it when you need descriptions, attributes, images, posted timestamps, updated timestamps, or map information. Detail mode makes more requests, so keep limits reasonable.

### Integrations

Use this actor with:

- 📈 Google Sheets or Excel exports for price monitoring.
- 🧱 Databases such as Postgres, BigQuery, or Airtable.
- 🔔 Alert workflows that notify you when matching listings appear.
- 🧪 Enrichment workflows that classify listings by product type, neighborhood, or lead quality.
- 🧰 Apify API, webhooks, and integrations for scheduled pipelines.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('<ANNA_APIFY_USERNAME>/craigslist-classifieds-scraper').call({
  startUrls: [{ url: 'https://sfbay.craigslist.org/search/sss?query=desk' }],
  maxItems: 25,
  includeDetails: true,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('<ANNA_APIFY_USERNAME>/craigslist-classifieds-scraper').call(run_input={
    'cityOrSite': 'sfbay',
    'category': 'sss',
    'query': 'desk',
    'maxItems': 25,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/<ANNA_APIFY_USERNAME>~craigslist-classifieds-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"cityOrSite":"sfbay","category":"sss","query":"desk","maxItems":25}'
```

### MCP usage

Connect this actor to Apify MCP at:

```text
https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/craigslist-classifieds-scraper
```

Claude Code setup:

```bash
claude mcp add apify-craigslist --url "https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/craigslist-classifieds-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-craigslist": {
      "url": "https://mcp.apify.com/?tools=<ANNA_APIFY_USERNAME>/craigslist-classifieds-scraper"
    }
  }
}
```

Example prompts:

- "Run Craigslist Classifieds Scraper for desks in sfbay and summarize price ranges."
- "Find apartment listings in a Craigslist city and export the dataset URL."
- "Monitor furniture listings and tell me which ones mention excellent condition."

### Best practices

- Start with one city and one category.
- Use `maxItems: 10` for the first run.
- Enable detail mode only when you need full descriptions or images.
- Schedule recurring runs at a respectful cadence.
- Save source URLs that encode your exact Craigslist filters.

### FAQ

#### Can I use any Craigslist city?

Yes. Use the city/site subdomain from the public Craigslist URL, such as `sfbay`, `newyork`, `losangeles`, `chicago`, `seattle`, or `austin`.

#### Does the actor open every listing page?

Only when `includeDetails` is enabled. Search-only mode is faster; detail mode returns richer descriptions, images, attributes, and timestamps.

### Troubleshooting

#### Why did I get fewer items than requested?

The source page may have fewer public listings for your query, or Craigslist may hide some cards for the selected city/category/filter combination. Broaden the query or remove filters.

#### Why are some detail fields empty?

Not every listing includes every public field. For example, some posts have no price, no map, no images, or no updated timestamp.

#### Can I scrape private contact details?

This actor is designed for public listing information. Respect Craigslist terms, privacy expectations, and applicable laws. Do not use scraped data for spam or prohibited outreach.

### Legality and responsible use

Craigslist pages can contain user-generated content. You are responsible for using this actor lawfully, respecting the website's terms, and complying with privacy, anti-spam, and data-protection rules. Only collect data you have a legitimate reason to process.

### Related scrapers

Explore other Apify Store actors by \<ANNA\_APIFY\_USERNAME> for complementary local-market, lead-generation, and monitoring workflows.

### Changelog

- Initial version: search result extraction, optional detail extraction, filters, proxy support, and structured dataset schema.

### Support

If a run fails, include the run URL, input, and a short description of what you expected to receive. For best results, include one public Craigslist URL that reproduces the issue.

# Actor input Schema

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

One or more public Craigslist search/category URLs, such as https://sfbay.craigslist.org/search/sss?query=desk. If empty, use the city/category/query fields below.

## `cityOrSite` (type: `string`):

Craigslist city subdomain to search when not using start URLs, for example sfbay, newyork, losangeles, chicago, seattle, or austin.

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

Craigslist category code. Common examples: sss = all for sale, apa = apartments, jjj = jobs, gms = garage sales, ccc = community.

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

Keyword to search for when city/category fields are used.

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

Maximum number of Craigslist listings to save. Keep this low for your first run.

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

When enabled, the actor visits each listing page to extract description, attributes, images, timestamps, and map data when public.

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

Optional Craigslist min\_price filter for categories that support prices.

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

Optional Craigslist max\_price filter for categories that support prices.

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

Set Craigslist hasPic=1 for searches where images are required.

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

Craigslist sort order for structured searches.

## `postedWithin` (type: `string`):

Limit structured search to today's posts, or scrape all visible matching posts.

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

Optional proxy configuration. Datacenter/Apify Proxy is usually enough for public Craigslist pages; use low concurrency and small limits.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://sfbay.craigslist.org/search/sss?query=desk"
    }
  ],
  "cityOrSite": "sfbay",
  "category": "sss",
  "query": "desk",
  "maxItems": 10,
  "includeDetails": true,
  "hasImage": false,
  "sort": "date",
  "postedWithin": "anytime",
  "proxyConfiguration": {
    "useApifyProxy": false,
    "apifyProxyGroups": []
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://sfbay.craigslist.org/search/sss?query=desk"
        }
    ],
    "cityOrSite": "sfbay",
    "category": "sss",
    "query": "desk",
    "maxItems": 10,
    "includeDetails": true,
    "sort": "date",
    "postedWithin": "anytime",
    "proxyConfiguration": {
        "useApifyProxy": false,
        "apifyProxyGroups": []
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/craigslist-classifieds-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 = {
    "startUrls": [{ "url": "https://sfbay.craigslist.org/search/sss?query=desk" }],
    "cityOrSite": "sfbay",
    "category": "sss",
    "query": "desk",
    "maxItems": 10,
    "includeDetails": True,
    "sort": "date",
    "postedWithin": "anytime",
    "proxyConfiguration": {
        "useApifyProxy": False,
        "apifyProxyGroups": [],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/craigslist-classifieds-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 '{
  "startUrls": [
    {
      "url": "https://sfbay.craigslist.org/search/sss?query=desk"
    }
  ],
  "cityOrSite": "sfbay",
  "category": "sss",
  "query": "desk",
  "maxItems": 10,
  "includeDetails": true,
  "sort": "date",
  "postedWithin": "anytime",
  "proxyConfiguration": {
    "useApifyProxy": false,
    "apifyProxyGroups": []
  }
}' |
apify call fetch_cat/craigslist-classifieds-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Classifieds Scraper",
        "description": "Scrape public Craigslist listings by city, category, keyword, price, and date. Export titles, prices, locations, images, descriptions, and attributes.",
        "version": "0.1",
        "x-build-id": "0fctYbZKXIXXyeGmX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~craigslist-classifieds-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-craigslist-classifieds-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/fetch_cat~craigslist-classifieds-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-craigslist-classifieds-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/fetch_cat~craigslist-classifieds-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-craigslist-classifieds-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": {
                    "startUrls": {
                        "title": "Craigslist search URLs",
                        "type": "array",
                        "description": "One or more public Craigslist search/category URLs, such as https://sfbay.craigslist.org/search/sss?query=desk. If empty, use the city/category/query fields below.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "cityOrSite": {
                        "title": "City/site subdomain",
                        "type": "string",
                        "description": "Craigslist city subdomain to search when not using start URLs, for example sfbay, newyork, losangeles, chicago, seattle, or austin.",
                        "default": "sfbay"
                    },
                    "category": {
                        "title": "Category code",
                        "type": "string",
                        "description": "Craigslist category code. Common examples: sss = all for sale, apa = apartments, jjj = jobs, gms = garage sales, ccc = community.",
                        "default": "sss"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Keyword to search for when city/category fields are used."
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of Craigslist listings to save. Keep this low for your first run.",
                        "default": 25
                    },
                    "includeDetails": {
                        "title": "Open listing detail pages",
                        "type": "boolean",
                        "description": "When enabled, the actor visits each listing page to extract description, attributes, images, timestamps, and map data when public.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional Craigslist min_price filter for categories that support prices."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional Craigslist max_price filter for categories that support prices."
                    },
                    "hasImage": {
                        "title": "Listings with images only",
                        "type": "boolean",
                        "description": "Set Craigslist hasPic=1 for searches where images are required.",
                        "default": false
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "date",
                            "rel",
                            "priceasc",
                            "pricedsc"
                        ],
                        "type": "string",
                        "description": "Craigslist sort order for structured searches.",
                        "default": "date"
                    },
                    "postedWithin": {
                        "title": "Posted within",
                        "enum": [
                            "anytime",
                            "today"
                        ],
                        "type": "string",
                        "description": "Limit structured search to today's posts, or scrape all visible matching posts.",
                        "default": "anytime"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy configuration. Datacenter/Apify Proxy is usually enough for public Craigslist pages; use low concurrency and small limits."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
