# Craigslist Scraper (`solidcode/craigslist-scraper`) Actor

\[💰 $1.4 / 1K] Extract Craigslist listings across cars, housing, jobs, electronics, furniture, services, gigs, and events. Filter by keyword, price, condition, or sort — or paste URLs directly. Each row includes title, price, location, description, images, post ID, and category-specific attributes.

- **URL**: https://apify.com/solidcode/craigslist-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Automation, Lead generation, Real estate
- **Stats:** 5 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 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

## Craigslist Scraper

Pull classified listings from Craigslist at scale — titles, prices, descriptions, images, post IDs, GPS coordinates, posted timestamps, and category-specific attributes (year, make, model, odometer, bedrooms, sqft, salary) across cars, housing, jobs, electronics, furniture, services, gigs, community, and events. Built for lead-gen sales teams, used-car dealers, real-estate investors, classifieds aggregators, journalists, and ML researchers who need a clean, structured Craigslist feed without paying $8 per 1,000 rows or wrestling with hundreds of city subdomains by hand.

### Why This Scraper?

- **Coverage of 50 major Craigslist regions** — New York, Los Angeles, San Francisco Bay Area, Chicago, Seattle, Boston, Toronto, Vancouver, Montreal and 41 more in a single dropdown. Need a smaller city? Paste the subdomain URL (raleigh, halifax, anything `*.craigslist.org`) and the actor figures out the rest.
- **13 category presets** — For Sale (all), Cars & Trucks, Electronics, Furniture, Apartments / Houses, Rooms & Shares, Sublets & Temporary, Jobs, Gigs, Services, Community, Resumes, and Events. No memorising Craigslist's three-letter abbreviations.
- **Six condition tiers plus four sort orders** — filter to New, Like New, Excellent, Good, Fair, or Salvage and choose Newest, Relevance, Lowest Price, or Highest Price ordering. Layer on min/max price, has-image, and posted-today toggles for tightly scoped pulls.
- **Per-listing detail enrichment** — every row carries the full body text, the complete `attributes` object (year, make, model, odometer, paint, fuel, transmission, bedrooms, sqft, employment type, compensation), the full image gallery, post ID, latitude/longitude, and posted/updated timestamps.
- **Paste search URLs OR detail URLs directly** — drop any Craigslist link into `startUrls` and the actor auto-detects whether it's a search results page (paginates and pulls cards) or an individual posting (fetches the detail page). Mix and match in a single run.
- **Bilingual + multi-currency aware** — handles English and French regions (Montreal, Quebec) and emits `currency: "CAD"` on the six Canadian markets (Toronto, Vancouver, Calgary, Ottawa, Edmonton, Montreal) versus `"USD"` everywhere else. No silent price-comparison bugs.
- **Surfaces deleted postings as `isDeleted: true`** — instead of crashing or silently dropping a row, removed listings are tagged so downstream catalogues can deactivate them and stay in sync.
- **Direct-contact extraction for lead-gen** — every detail-enriched row carries `phoneNumbers[]` and `emails[]` parsed from the posting body, plus a `contactObfuscated` boolean that flips to `false` whenever a real phone or email is published. Filter `contactObfuscated == false` for outbound-ready leads, or sort by `len(phoneNumbers) + len(emails)` to prioritise the most reachable posters.
- **Up to 24 image URLs per posting** — full-resolution gallery, not thumbnails, sourced from the JSON-LD product blob with embedded JS fallback.

### Use Cases

**Lead Generation**
- Build live used-car-buyer lead lists with prices, mileage, and seller location
- Surface FSBO real-estate sellers in target ZIP codes for outbound campaigns
- Capture small-business equipment posters across services and gigs categories
- Filter postings where contact info is published versus relayed for higher-conversion outreach

**Market Research & Pricing**
- Track median prices for used cars by make/model/year across 50 metros
- Compare apartment rental asking prices week over week in growth markets
- Monitor inventory turnover by counting daily new postings against deletions
- Benchmark electronics resale prices against retail for arbitrage signals

**Competitive Intelligence**
- Power classifieds aggregator portals with normalised cross-region data
- Feed dropshipping and resale platforms with daily Craigslist deal candidates
- Monitor competitor dealer postings across cars-by-dealer and furniture-by-dealer categories
- Index local services pricing for service-marketplace startups

**Academic & ML Research**
- Train language models on millions of unstructured classifieds descriptions
- Study regional housing affordability through scraped rent and sublet listings
- Analyse labour market demand using Craigslist Jobs and Gigs categories
- Build geographic price-distribution datasets keyed on the lat/lng fields

**Journalism & Civic Analysis**
- Track gig economy labour conditions through Gigs category postings
- Document informal housing markets from Rooms & Shares and Sublets categories
- Surface community events and notices for local-news beat coverage
- Investigate scam patterns by sampling repeated obfuscated-contact postings

### Getting Started

#### Quick start — city + keyword

The simplest run: pick a city, type a search term, set a row cap.

```json
{
    "region": "sfbay",
    "searchTerm": "honda civic",
    "maxResults": 100
}
````

#### Filtered cars search

Cars & Trucks in New York, like-new condition, $5k–$20k, photos required, newest first.

```json
{
    "region": "newyork",
    "category": "cta",
    "priceMin": 5000,
    "priceMax": 20000,
    "condition": "like-new",
    "hasImage": true,
    "sort": "date",
    "maxResults": 200
}
```

#### Mix search URLs and detail URLs

Paste any combination of search-page URLs and individual posting URLs in one run. The actor auto-detects each.

```json
{
    "startUrls": [
        "https://sfbay.craigslist.org/search/apa?max_price=3500&hasPic=1",
        "https://losangeles.craigslist.org/search/cta?query=tacoma&condition=30",
        "https://newyork.craigslist.org/mnh/clo/d/example-listing/7903726578.html"
    ],
    "sort": "priceasc",
    "maxResults": 500
}
```

### Input Reference

#### Where to Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste one or more Craigslist URLs. Accepts search pages, category pages, and individual posting URLs. When provided, these override the City + Category + Keyword fields. Plain URLs only. |
| `region` | select | `New York City, NY` | Craigslist city to search. Covers the most popular US and Canadian regions. If your city isn't listed, paste a Craigslist URL above instead — any subdomain works. |
| `category` | select | `For sale (all)` | What kind of listings to collect. Choose For Sale (all), Cars & Trucks, Electronics, Furniture, Apartments / Houses, Rooms & Shares, Sublets & Temporary, Jobs, Gigs, Services, Community, Resumes, or Events. |
| `searchTerm` | string | `null` | Optional keyword. Matches against the title and body of postings. Leave empty to return every listing in the selected category. |

#### Filters

Optional filters applied at the Craigslist server side, so you only collect rows that already match.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `priceMin` | integer | `null` | Only include postings priced at or above this amount. Ignored on categories without prices (Jobs, Community, Resumes). |
| `priceMax` | integer | `null` | Only include postings priced at or below this amount. |
| `condition` | select | `Any condition` | Restrict to a specific condition (For Sale categories only): New, Like new, Excellent, Good, Fair, or Salvage. |
| `hasImage` | boolean | `false` | When on, only return postings that have at least one photo. |
| `postedToday` | boolean | `false` | When on, only return postings published in the last 24 hours. |
| `sort` | select | `Newest first` | How Craigslist orders the search results: Newest first, Relevance, Lowest price first, or Highest price first. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | When on (default), every search result is followed with a second request to fetch the full description, attributes, complete image gallery, post ID, and posted timestamp. Turn off for faster runs that return only the search-card fields. |
| `maxResults` | integer | `200` | Hard cap on total postings across all sources. Set to 0 for no cap (an internal upper limit of 100,000 still applies). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots. |

### Output

One flat row per listing. Here's a representative result with full details enabled:

```json
{
    "url": "https://newyork.craigslist.org/mnh/clo/d/new-york-1860s-fan/7903726578.html",
    "postId": "7903726578",
    "title": "1860s fan",
    "priceUsd": 9,
    "currency": "USD",
    "region": "newyork",
    "categorySlug": "sss",
    "categoryLabel": "For Sale",
    "subcategorySlug": "clo",
    "subcategoryLabel": null,
    "postedAt": "2025-12-20T17:30:19-0500",
    "updatedAt": null,
    "location": "(Upper East Side)",
    "latitude": 40.7651,
    "longitude": -73.9624,
    "attributes": {
        "condition": "good",
        "size_/_dimensions": "12 inch"
    },
    "description": "Antique hand fan from the 1860s. Carved bone sticks, hand-painted silk leaf with floral motif. Some wear consistent with age. From an estate collection — pickup in Manhattan.",
    "imageUrls": [
        "https://images.craigslist.org/00b0b_example1_600x450.jpg",
        "https://images.craigslist.org/00f0f_example2_600x450.jpg"
    ],
    "hasImages": true,
    "contactObfuscated": false,
    "phoneNumbers": ["(917) 325-5214"],
    "emails": ["seller@example.com"],
    "replyToken": "nyc/clo/7903726578",
    "isDeleted": false,
    "scrapedAt": "2026-05-10T14:30:00Z"
}
```

(Description and image arrays are truncated above for readability — the live row carries the full posting body and every gallery image.)

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Canonical posting URL |
| `postId` | string | Craigslist's numeric post identifier |
| `title` | string | Posting headline |
| `priceUsd` | number | null | Numeric price (named `priceUsd` for legacy reasons; populated for every region in the local currency) |
| `currency` | string | ISO currency code — `USD` for US regions, `CAD` for the six Canadian markets |
| `region` | string | City subdomain (e.g. `sfbay`, `newyork`, `toronto`) |
| `scrapedAt` | string | ISO 8601 timestamp of when this row was captured |

#### Category & Location

| Field | Type | Description |
|-------|------|-------------|
| `categorySlug` | string | Craigslist category code (`sss`, `cta`, `apa`, etc.) |
| `categoryLabel` | string | Human-readable category name |
| `subcategorySlug` | string | null | Detail-level subcategory (`bik`, `cto`, `mca`, etc.) when known |
| `subcategoryLabel` | string | null | Human-readable subcategory name |
| `location` | string | null | Free-text neighbourhood as Craigslist displays it (e.g. "(Upper East Side)") |
| `latitude` | number | null | Posting latitude — note Craigslist jitters by ~0.05 degrees for privacy |
| `longitude` | number | null | Posting longitude — same neighbourhood-level precision caveat |

#### Description & Attributes

Populated when `includeDetails` is on.

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full posting body, with QR-code and reply-button noise stripped |
| `attributes` | object | Flexible per-category attribute map — typical keys include `condition`, `make`, `model`, `year`, `odometer`, `paint`, `fuel`, `transmission`, `bedrooms`, `sqft`, `employment_type`, `compensation` |
| `postedAt` | string | ISO 8601 timestamp when the posting was first published |
| `updatedAt` | string | null | ISO 8601 timestamp of last update — null when never updated |

#### Media & Status

| Field | Type | Description |
|-------|------|-------------|
| `imageUrls` | string\[] | Full-resolution image URLs from the posting gallery |
| `hasImages` | boolean | True when at least one image is attached |
| `phoneNumbers` | string\[] | Phone numbers parsed from the posting body, formatted as `(NNN) NNN-NNNN`. Empty when the poster only exposes Craigslist's reply relay. Populated when `includeDetails` is on. |
| `emails` | string\[] | Email addresses parsed from the posting body. Excludes Craigslist's own `@reply.craigslist.org` relay addresses. Populated when `includeDetails` is on. |
| `contactObfuscated` | boolean | `false` when at least one direct phone or email was extracted; `true` when the poster only publishes Craigslist's relay link |
| `replyToken` | string | null | Path component from the reply CTA — `<region>/<cat>/<postId>` — useful for de-duplicating across crawls |
| `isDeleted` | boolean | True when the posting returns "this post has been deleted" or 404s on the detail fetch |

### Tips for Best Results

- **Use the canonical city subdomain.** `sfbay`, not `sf`; `washingtondc`, not `dc`; `losangeles`, not `la`. The dropdown handles this for you, but if you paste a URL, double-check the host. Common aliases (`sf`, `la`, `nyc`, `dc`) are auto-corrected — anything else is sent as-is.
- **Disable `includeDetails` for high-volume monitoring jobs.** Detail fetches roughly double run time and pricing because each posting becomes two requests. For daily inventory sweeps where you'll re-fetch detail later, turn it off and you'll get title, price, link, location, and post ID at full speed.
- **Treat `latitude`/`longitude` as neighbourhood-level.** Craigslist intentionally jitters geo coordinates by roughly 0.05 degrees (~5 km) for poster privacy. They're great for clustering and metro-area heatmaps, useless for pinpointing an address.
- **Pair `condition: like-new` with `priceMin`** when hunting deals on cars or electronics — this catches motivated sellers while filtering out flippers who under-grade gear to drive negotiation.
- **Mix search URLs and detail URLs in one run.** Maintain a watchlist of specific postings (passed as detail URLs) alongside fresh discovery searches (passed as search URLs) — they all land in the same dataset.
- **For Canadian markets, expect `currency: "CAD"`.** Toronto, Vancouver, Calgary, Ottawa, Edmonton, and Montreal return Canadian-dollar prices automatically. If your downstream pipeline assumes USD, branch on the `currency` field rather than the `region`.
- **Use `isDeleted` for catalogue freshness.** Re-running the same query will return `isDeleted: true` rows for postings that disappeared between runs. Sync this flag into your downstream system so your inventory matches reality.
- **Filter `contactObfuscated == false` (or non-empty `phoneNumbers`/`emails`) for ready-to-reach leads.** Most Craigslist postings hide contact behind the reply relay; the ones that publish a phone or email are the ones who want a direct call. Pair `condition: like-new` with non-empty `phoneNumbers` for direct-contact lead lists in resale categories.

### Pricing

**$1.40 per 1,000 results** — flat pay-per-result. No compute charges — you only pay per result returned.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.14 |
| 1,000 | $1.40 |
| 10,000 | $14.00 |
| 100,000 | $140.00 |

A "result" is any row in the output dataset — one posting equals one result, whether or not detail enrichment is on.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, lead generation, journalism, and academic analysis of public Craigslist postings. Users are responsible for complying with applicable laws, Craigslist's Terms of Use, and local data-protection regulations. Do not use the extracted data for spam, harassment, mass-unsolicited contact, fraud, or any other unlawful purpose. Be especially mindful of fair-housing and equal-employment regulations when working with housing and jobs data.

# Actor input Schema

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

Paste one or more Craigslist URLs. Accepts search pages (https://sfbay.craigslist.org/search/sss?query=bike), category pages (https://newyork.craigslist.org/search/cta), and individual posting URLs. When provided, these override the City + Category + Keyword fields below. Plain URLs only — do not wrap them in JSON objects.

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

Craigslist city to search. Covers the most popular US and Canadian regions. If your city isn't listed, paste a Craigslist URL above instead — any city subdomain works (e.g. raleigh.craigslist.org, halifax.craigslist.org).

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

What kind of listings to collect. "For sale (all)" returns the full for-sale catalogue; the more specific subcategories (Cars & Trucks, Electronics, Furniture, Housing) narrow Craigslist's own search.

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

Optional search keyword. Matches against the title and body of postings (e.g. "honda civic", "two bedroom", "vintage camera"). Leave empty to return every listing in the selected category.

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

Only include postings priced at or above this amount. Leave empty for no minimum. Ignored on categories that don't have prices (Jobs, Community, Resumes).

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

Only include postings priced at or below this amount. Leave empty for no maximum.

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

Restrict to a specific condition (For Sale categories only). Most posters tag this honestly; some leave it blank, which means the row is excluded when this filter is set.

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

When on, only return postings that have at least one photo.

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

When on, only return postings published in the last 24 hours.

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

How Craigslist orders the search results.

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

When on (default), every search result is followed with a second request to the posting page so the row carries the full description body, all attributes, the complete image gallery, exact post ID, and posted timestamp. Turn off for faster, cheaper runs that return only what's visible on the search results card (title, price, link, thumbnail).

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

Hard cap on total postings across all sources. Default 200 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 100,000 still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.

## Actor input object example

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

# Actor output Schema

## `overview` (type: `string`):

Table of scraped Craigslist listings with the most useful columns at a glance.

## `details` (type: `string`):

Full posting details with description, attributes, images, and contact metadata.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [],
    "region": "newyork",
    "category": "sss",
    "condition": "any",
    "hasImage": false,
    "postedToday": false,
    "sort": "date",
    "includeDetails": true,
    "maxResults": 200
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Scraper",
        "description": "[💰 $1.4 / 1K] Extract Craigslist listings across cars, housing, jobs, electronics, furniture, services, gigs, and events. Filter by keyword, price, condition, or sort — or paste URLs directly. Each row includes title, price, location, description, images, post ID, and category-specific attributes.",
        "version": "1.0",
        "x-build-id": "peJ204fxrrXiC4hcH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~craigslist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~craigslist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~craigslist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "startUrls": {
                        "title": "Craigslist URLs",
                        "type": "array",
                        "description": "Paste one or more Craigslist URLs. Accepts search pages (https://sfbay.craigslist.org/search/sss?query=bike), category pages (https://newyork.craigslist.org/search/cta), and individual posting URLs. When provided, these override the City + Category + Keyword fields below. Plain URLs only — do not wrap them in JSON objects.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "City",
                        "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": "Craigslist city to search. Covers the most popular US and Canadian regions. If your city isn't listed, paste a Craigslist URL above instead — any city subdomain works (e.g. raleigh.craigslist.org, halifax.craigslist.org).",
                        "default": "newyork"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "sss",
                            "cta",
                            "ela",
                            "fua",
                            "apa",
                            "roo",
                            "sub",
                            "jjj",
                            "ggg",
                            "bbb",
                            "ccc",
                            "rrr",
                            "eee"
                        ],
                        "type": "string",
                        "description": "What kind of listings to collect. \"For sale (all)\" returns the full for-sale catalogue; the more specific subcategories (Cars & Trucks, Electronics, Furniture, Housing) narrow Craigslist's own search.",
                        "default": "sss"
                    },
                    "searchTerm": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Optional search keyword. Matches against the title and body of postings (e.g. \"honda civic\", \"two bedroom\", \"vintage camera\"). Leave empty to return every listing in the selected category."
                    },
                    "priceMin": {
                        "title": "Minimum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include postings priced at or above this amount. Leave empty for no minimum. Ignored on categories that don't have prices (Jobs, Community, Resumes)."
                    },
                    "priceMax": {
                        "title": "Maximum Price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include postings priced at or below this amount. Leave empty for no maximum."
                    },
                    "condition": {
                        "title": "Condition",
                        "enum": [
                            "any",
                            "new",
                            "like-new",
                            "excellent",
                            "good",
                            "fair",
                            "salvage"
                        ],
                        "type": "string",
                        "description": "Restrict to a specific condition (For Sale categories only). Most posters tag this honestly; some leave it blank, which means the row is excluded when this filter is set.",
                        "default": "any"
                    },
                    "hasImage": {
                        "title": "Has image",
                        "type": "boolean",
                        "description": "When on, only return postings that have at least one photo.",
                        "default": false
                    },
                    "postedToday": {
                        "title": "Posted today",
                        "type": "boolean",
                        "description": "When on, only return postings published in the last 24 hours.",
                        "default": false
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "date",
                            "rel",
                            "priceasc",
                            "pricedsc"
                        ],
                        "type": "string",
                        "description": "How Craigslist orders the search results.",
                        "default": "date"
                    },
                    "includeDetails": {
                        "title": "Include full posting details",
                        "type": "boolean",
                        "description": "When on (default), every search result is followed with a second request to the posting page so the row carries the full description body, all attributes, the complete image gallery, exact post ID, and posted timestamp. Turn off for faster, cheaper runs that return only what's visible on the search results card (title, price, link, thumbnail).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total postings across all sources. Default 200 — increase for bigger runs, or set to 0 for no cap (an internal upper limit of 100,000 still applies to prevent runaway pagination). The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
