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

Scrape Craigslist listings across cars, housing, jobs, electronics, furniture, services, gigs, and events. Filter by keyword, price, condition, or sort. Each row includes title, price, location, description, images, post ID, and category-specific attributes. Export as JSON, CSV, Excel.

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

## Pricing

from $1.00 / 1,000 craigslist listings

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

Scrape [Craigslist](https://craigslist.org) listings across 50+ US and Canadian cities and 13 categories — cars, housing, jobs, electronics, furniture, services, gigs, and events. Extract titles, prices, descriptions, images, GPS coordinates, post IDs, seller contact info, and category-specific attributes into structured data. Built for lead generation teams, market researchers, real estate investors, and data engineers who need clean, structured Craigslist data without managing hundreds of city subdomains by hand.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by city, category, keyword, price range, condition, and sort order — or paste any Craigslist URL directly. Get structured listing data with full descriptions, attribute maps, image galleries, GPS coordinates, and parsed phone numbers and emails ready for analysis.
</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

````

Craigslist Scraper (parsebird/craigslist-scraper) — Scrapes Craigslist listings across 50+ cities and 13 categories. Input: {"region": "sfbay", "category": "sss", "searchTerm": "honda civic", "maxResults": 25}. Also accepts startUrls: \["https://sfbay.craigslist.org/search/cta?query=tacoma"]. Filters: priceMin, priceMax, condition (new/like-new/excellent/good/fair/salvage), hasImage, postedToday, sort (date/rel/priceasc/pricedsc). Set includeDetails: true for full descriptions, attributes, images, timestamps, phone/email extraction. Outputs per listing: url, postId, title, priceUsd, currency, region, categorySlug, categoryLabel, subcategorySlug, location, latitude, longitude, description, attributes (condition, make, model, year, odometer, bedrooms, sqft), imageUrls, postedAt, updatedAt, phoneNumbers, emails, contactObfuscated, isDeleted, scrapedAt. API: POST https://api.apify.com/v2/acts/parsebird~craigslist-scraper/runs?token=YOUR\_TOKEN. Get token: https://console.apify.com/account#/integrations

````

### What does Craigslist Scraper do?

The Craigslist Scraper turns any [Craigslist](https://craigslist.org) city and category combination — or any pasted Craigslist URL — into structured JSON, CSV, or Excel data. Pick a city, choose a category, optionally add a keyword, and the scraper:

- 🔍 Searches Craigslist's internal JSON API for fast, reliable results (no HTML scraping for search)
- 📄 Enriches every listing with full descriptions, attributes, and image galleries from the detail page
- 📍 Extracts GPS coordinates (latitude/longitude) for geographic analysis and heatmaps
- 📞 Parses phone numbers and email addresses from posting bodies for direct-contact lead lists
- 🏷️ Captures category-specific attributes — condition, make, model, year, odometer, bedrooms, sqft, compensation
- 🇨🇦 Handles Canadian regions automatically with `currency: "CAD"` for Toronto, Vancouver, Calgary, Ottawa, Edmonton, and Montreal
- 🗑️ Detects deleted or flagged postings and tags them as `isDeleted: true` instead of crashing
- ⚡ Runs on lightweight infrastructure (128 MB) — fast and cost-efficient

Paste search URLs and individual posting URLs in the same run — the Craigslist Scraper auto-detects each type and routes accordingly.

### What data can you extract from Craigslist?

| Field | Description |
|-------|-------------|
| `url` | Canonical posting URL |
| `postId` | Craigslist's numeric post identifier |
| `title` | Posting headline |
| `priceUsd` | Numeric price in local currency (USD or CAD) |
| `currency` | ISO currency code — `USD` or `CAD` |
| `region` | City subdomain (e.g. `sfbay`, `newyork`, `toronto`) |
| `categorySlug`, `categoryLabel` | Category code and human-readable name |
| `location` | Neighbourhood as displayed by Craigslist |
| `latitude`, `longitude` | GPS coordinates (neighbourhood-level precision) |
| `description` | Full posting body text |
| `attributes` | Per-category attribute map (condition, make, model, year, odometer, bedrooms, sqft) |
| `postedAt`, `updatedAt` | ISO 8601 timestamps |
| `imageUrls` | Full-resolution image URLs from the gallery |
| `phoneNumbers` | Phone numbers parsed from the posting body |
| `emails` | Email addresses parsed from the posting body |
| `contactObfuscated` | `false` when direct contact info is available |
| `isDeleted` | `true` when the posting has been removed |
| `scrapedAt` | ISO 8601 timestamp of when this row was captured |

### How to scrape Craigslist

1. Open the [Craigslist Scraper](https://apify.com/parsebird/craigslist-scraper) on Apify
2. Select a **City** from the dropdown (50+ US and Canadian regions)
3. Choose a **Category** — For Sale, Cars & Trucks, Apartments, Jobs, Gigs, Services, and more
4. Optionally add a **Keyword** (e.g. "honda civic", "two bedroom", "vintage camera")
5. Set filters: price range, condition, has image, posted today, sort order
6. Set **Max results** to control how many listings to collect
7. Click **Start** and wait for results
8. Export your data as JSON, CSV, or Excel from the dataset tab

**Alternatively**, paste any Craigslist URL directly into the **Craigslist URLs** field — the scraper extracts the city, category, and filters from the URL automatically.

**Quick start input:**

```json
{
    "region": "sfbay",
    "searchTerm": "honda civic",
    "maxResults": 25
}
````

**Filtered cars search:**

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

**Mixed URLs input:**

```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 parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `startUrls` | string\[] | No | — | Craigslist search or posting URLs. Overrides city/category/keyword when provided. |
| `region` | select | No | New York City, NY | Craigslist city to search (50+ US and Canadian regions) |
| `category` | select | No | For sale (all) | Category to collect: For Sale, Cars, Electronics, Furniture, Housing, Jobs, Gigs, Services, Community, Resumes, Events |
| `searchTerm` | string | No | — | Optional keyword to match against title and body |
| `priceMin` | integer | No | — | Minimum price filter |
| `priceMax` | integer | No | — | Maximum price filter |
| `condition` | select | No | Any | Condition filter: New, Like new, Excellent, Good, Fair, Salvage |
| `hasImage` | boolean | No | false | Only return postings with photos |
| `postedToday` | boolean | No | false | Only return postings from the last 24 hours |
| `sort` | select | No | Newest first | Sort: Newest, Relevance, Lowest price, Highest price |
| `includeDetails` | boolean | No | true | Fetch full description, attributes, images, and timestamps per listing |
| `maxResults` | integer | No | 200 | Hard cap on total postings. Set to 0 for no cap (100,000 internal limit). |

### Output example

```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",
    "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"],
    "isDeleted": false,
    "scrapedAt": "2026-06-20T14:30:00Z"
}
```

Download results in JSON, CSV, Excel, XML, or JSONL from the Apify dataset UI or [REST API](https://docs.apify.com/api/v2).

### Use cases

- 🚗 **Lead generation** — Build used-car buyer lead lists with prices, mileage, and seller phone numbers across 50+ cities
- 🏠 **Real estate research** — Track apartment rental prices and FSBO listings in target metro areas
- 📊 **Market research** — Compare prices across regions, monitor inventory turnover, and benchmark resale values
- 🔍 **Competitive intelligence** — Feed classifieds aggregator portals with normalized cross-region Craigslist data
- 📰 **Journalism** — Document gig economy labour conditions, informal housing markets, and community trends
- 🤖 **ML & academic research** — Train language models on millions of unstructured classifieds descriptions with structured metadata
- 📦 **Resale & arbitrage** — Surface underpriced electronics, furniture, and vehicle deals using price and condition filters

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

| Plan | Price per 1,000 listings |
|------|--------------------------|
| Free, Bronze, Silver | **$1.30** |
| Gold | **$1.00** |

Each listing extracted and pushed to the dataset counts as one `listing-scraped` event. Platform usage (compute, proxy, storage) is included in the per-event price — you are not charged separately for Apify platform costs.

**Example costs:**

| Listings | Silver plan | Gold plan |
|----------|------------|-----------|
| 100 | $0.13 | $0.10 |
| 1,000 | $1.30 | $1.00 |
| 10,000 | $13.00 | $10.00 |
| 100,000 | $130.00 | $100.00 |

Turning off **Include full posting details** roughly halves the number of HTTP requests per run (no detail page fetches), making large monitoring jobs faster.

Start with a [free Apify trial](https://apify.com/pricing) to test the Craigslist Scraper with your search queries.

### Integrations and API access

Run this actor programmatically via the [Apify REST API](https://docs.apify.com/api/v2), or integrate with:

- **Python**: `pip install apify-client`
- **JavaScript/TypeScript**: `npm install apify-client`
- **Zapier, Make, n8n**: Connect via [Apify integrations](https://docs.apify.com/platform/integrations)
- **Google Sheets**: Export directly from the dataset
- **Webhooks**: Trigger downstream pipelines on run completion

**Python example:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("parsebird/craigslist-scraper").call(run_input={
    "region": "sfbay",
    "category": "cta",
    "searchTerm": "honda civic",
    "priceMax": 15000,
    "maxResults": 25,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item['title']} - ${item['priceUsd']} - {item['location']}")
```

**JavaScript example:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor("parsebird/craigslist-scraper").call({
    region: "sfbay",
    category: "cta",
    searchTerm: "honda civic",
    priceMax: 15000,
    maxResults: 25,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(`${item.title} - $${item.priceUsd} - ${item.location}`));
```

Schedule runs hourly, daily, or weekly using [Apify Scheduling](https://docs.apify.com/platform/schedules) for automated Craigslist monitoring and lead generation.

### Is it legal to scrape Craigslist?

Web scraping of publicly available data is generally considered legal. This Craigslist Scraper only accesses publicly available classified listings on [Craigslist](https://craigslist.org) — the same data visible to any visitor in a web browser. It does not bypass authentication, CAPTCHAs, or access restricted content.

For more information, see Apify's article on [web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

**Important:** You are responsible for ensuring your use of scraped data complies 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.

### Other Craigslist scrapers and related actors

- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) — Remove duplicate entries from scraped Craigslist datasets
- [Data Cleaner](https://apify.com/parsebird/data-cleaner) — Clean and transform scraped data before analysis
- [HTTP Request Actor](https://apify.com/parsebird/http-request-actor) — Make custom HTTP requests to any Craigslist endpoint

### FAQ

**How many listings can I scrape per run?**
Set `maxResults` up to 100,000 per run. The default is 25 to keep first runs fast and cheap. For large-scale collection, set `maxResults` to 0 (no cap) and let the actor paginate through all available results.

**What's the difference between `includeDetails` on and off?**
With `includeDetails` on, every search result gets a second request to the posting page, adding the full description, all attributes, the complete image gallery, exact timestamps, and parsed phone numbers and emails. It's off by default for faster, cheaper runs that return only title, price, link, location, and post ID.

**Does it work with Canadian Craigslist cities?**
Yes. Toronto, Vancouver, Calgary, Ottawa, Edmonton, and Montreal are all included. Prices from these regions are automatically tagged with `currency: "CAD"`.

**Can I paste any Craigslist URL?**
Yes. The Craigslist Scraper accepts search pages, category pages, and individual posting URLs. You can mix and match them in a single run. The actor auto-detects whether each URL is a search or a detail page.

**How fresh is the data?**
Every run fetches live data directly from Craigslist — no cached or stale results. Use the `postedToday` filter to collect only postings from the last 24 hours.

**Can I schedule recurring runs?**
Yes. Use [Apify's scheduler](https://docs.apify.com/platform/schedules) to run the Craigslist Scraper daily, weekly, or at any custom interval for automated monitoring.

**Can I filter by condition?**
Yes. Choose from New, Like New, Excellent, Good, Fair, or Salvage. This filter applies to For Sale categories only.

**What output formats are available?**
JSON, CSV, Excel, XML, and JSONL — all available from the Apify dataset tab and [REST API](https://docs.apify.com/api/v2).

**Can I use this with AI agents and LLMs?**
Yes. Connect via [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) for use with Claude, ChatGPT, Cursor, and other LLM-powered tools. The AI assistant copy block above gives any LLM the context it needs to call this actor.

**How do I report issues?**
Use the [Issues tab](https://apify.com/parsebird/craigslist-scraper/issues) on the actor page. We monitor it and respond promptly.

### Legal and compliance

This actor accesses only publicly available classified listings from [Craigslist](https://craigslist.org). No login credentials, authentication tokens, or private APIs are used. Users are responsible for ensuring their use of the data complies with all applicable laws, regulations, and the target website's terms of service. Apify provides the infrastructure; how you use the data is your responsibility.

# 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.

## `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.

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

What kind of listings to collect. 'For sale (all)' returns the full for-sale catalogue; more specific subcategories narrow the 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 without 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, every search result is followed with a second request to fetch the full description, attributes, complete image gallery, post ID, and posted timestamp. Off by default for faster, cheaper runs that return only search-card fields.

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

Hard cap on total postings. Default 25 — increase for bigger runs, or set to 0 for no cap (an internal limit of 100,000 still applies). The actor stops requesting new pages once this number is reached.

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

Datacenter proxies work for most runs. Switch to residential proxies if you see frequent blocks or empty results.

## Actor input object example

```json
{
  "startUrls": [
    "https://sfbay.craigslist.org/search/sss?query=bike"
  ],
  "region": "sfbay",
  "category": "sss",
  "condition": "any",
  "hasImage": false,
  "postedToday": false,
  "sort": "date",
  "includeDetails": false,
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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": [
        "https://sfbay.craigslist.org/search/sss?query=bike"
    ],
    "region": "sfbay",
    "category": "sss",
    "maxResults": 25,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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": ["https://sfbay.craigslist.org/search/sss?query=bike"],
    "region": "sfbay",
    "category": "sss",
    "maxResults": 25,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/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": [
    "https://sfbay.craigslist.org/search/sss?query=bike"
  ],
  "region": "sfbay",
  "category": "sss",
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parsebird/craigslist-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Scraper",
        "description": "Scrape Craigslist listings across cars, housing, jobs, electronics, furniture, services, gigs, and events. Filter by keyword, price, condition, or sort. Each row includes title, price, location, description, images, post ID, and category-specific attributes. Export as JSON, CSV, Excel.",
        "version": "1.0",
        "x-build-id": "a90MmjZB1jxdGOS6b"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~craigslist-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-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/parsebird~craigslist-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-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/parsebird~craigslist-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-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.",
                        "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.",
                        "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; more specific subcategories narrow the 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 without 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, every search result is followed with a second request to fetch the full description, attributes, complete image gallery, post ID, and posted timestamp. Off by default for faster, cheaper runs that return only search-card fields.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on total postings. Default 25 — increase for bigger runs, or set to 0 for no cap (an internal limit of 100,000 still applies). The actor stops requesting new pages once this number is reached.",
                        "default": 25
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Datacenter proxies work for most runs. Switch to residential proxies if you see frequent blocks or empty results.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
