# Craigslist Real Estate Scraper | FSBO & Rentals (`parsebird/craigslist-real-estate-scraper`) Actor

Extract Craigslist real estate listings: prices, beds, baths, square footage, photos, descriptions, owner/dealer flags, and public contact signals. Search cities or paste listing URLs. Export as JSON, CSV, Excel.

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

## Pricing

from $2.69 / 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.
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 Real Estate Scraper | FSBO Listings & Rentals

Scrape public [Craigslist](https://www.craigslist.org/) real estate listings for FSBO homes, rentals, rooms, sublets, and vacation rentals with structured prices, bedrooms, bathrooms, square footage, photos, descriptions, owner/dealer signals, and public contact indicators.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">Search Craigslist real estate by city, housing category, price, bedrooms, ZIP radius, owner/dealer type, or direct listing URLs, then export clean property data for analysis, monitoring, or lead workflows.</td>
</tr></table>

##### Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

```text
Apify Actor: parsebird/craigslist-real-estate-scraper - scrapes public Craigslist real estate listings. Call via ApifyClient: client.actor("parsebird/craigslist-real-estate-scraper").call(run_input={"mode":"search","city":"sfbay","category":"rea","listingType":"owner","minPrice":200000,"maxPrice":900000,"minBedrooms":2,"maxListings":25,"includePhotos":true,"includeContactInfo":true}). Inputs: mode (search/direct_urls, default search), city (Craigslist city code, default sfbay), category (apa/rea/roo/sub/vac, default rea), listingType (all/owner/dealer, default all), minPrice, maxPrice, minBedrooms, postalCode, searchDistance, maxListings (1-500, default 25), includePhotos, includeContactInfo, directUrls. Output fields: url, title, price, bedrooms, bathrooms, sqft, location, posting_date, photos, body, attributes, by_owner, housing_type, contact_available, phone_numbers, emails, scraped_at. API docs: https://docs.apify.com/api/v2 Token: https://console.apify.com/settings/integrations
````

### What is Craigslist Real Estate Scraper | FSBO Listings & Rentals?

**Craigslist Real Estate Scraper | FSBO Listings & Rentals** is a Craigslist scraper for public housing listings. It collects structured property data from Craigslist categories such as apartments, real estate for sale, rooms, sublets, and vacation rentals.

Use it as a **Craigslist real estate API alternative** when you need repeatable data exports, scheduled monitoring, or integration-ready property datasets without manually browsing city pages.

### What can Craigslist Real Estate Scraper do?

- Search Craigslist real estate by city code, category, owner/dealer type, price range, bedrooms, ZIP code, and radius.
- Scrape direct Craigslist listing URLs when you already have specific public property pages.
- Extract public listing details including title, price, beds, baths, square footage, neighborhood, description, attributes, photos, and listing URL.
- Detect FSBO/by-owner signals from category codes and visible listing text when Craigslist exposes them.
- Extract only public phone numbers and emails visible in the listing body when `includeContactInfo` is enabled.
- Run on Apify with scheduling, API access, proxy support, integrations, and exports to JSON, CSV, and Excel.

### What data can you extract from Craigslist real estate listings?

| Field | Description |
|-------|-------------|
| `url` | Public Craigslist listing URL |
| `title` | Listing title |
| `price` | Listing price when visible |
| `bedrooms` / `bathrooms` | Bedroom and bathroom counts parsed from attributes or text |
| `sqft` | Square footage when visible |
| `location` | Neighborhood, address hint, or map address when Craigslist exposes it |
| `posting_date` | Public posted timestamp when available on the listing page |
| `photos` | Public Craigslist image URLs |
| `body` | Cleaned listing description text |
| `attributes` | Visible Craigslist attribute chips such as `2br`, `1ba`, or `950ft2` |
| `by_owner` | Boolean owner/FSBO signal inferred from visible Craigslist signals |
| `housing_type` | Parsed housing type such as condo, house, apartment, studio, room, or land |
| `contact_available` | Whether public phone/email contact text was found |
| `phone_numbers` / `emails` | Public contact strings found in the listing body |
| `scraped_at` | UTC timestamp for the scrape |

### How to scrape Craigslist real estate listings

1. Open the actor on Apify and choose `search` mode.
2. Enter a Craigslist city code such as `sfbay`, `newyork`, `losangeles`, or `chicago`.
3. Pick a category: `rea` for real estate for sale, `apa` for apartments, `roo` for rooms, `sub` for sublets, or `vac` for vacation rentals.
4. Add optional filters such as `listingType`, price range, minimum bedrooms, postal code, search distance, and `includePhotos`.
5. Set `maxListings` between 1 and 500.
6. Run the actor and download results in JSON, CSV, Excel, or HTML from the dataset.
7. Use Apify scheduling to monitor Craigslist cities daily or connect results to [Apify integrations](https://apify.com/integrations), Make, Zapier, n8n, webhooks, or your own API workflow.

For exact listing pages, set `mode` to `direct_urls` and paste public Craigslist listing URLs into `directUrls`.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `mode` | string | No | `search` | Use `search` for city/category scraping or `direct_urls` for exact listing URLs |
| `city` | string | No | `sfbay` | Craigslist city code |
| `category` | string | No | `rea` | Housing category: `apa`, `rea`, `roo`, `sub`, or `vac` |
| `listingType` | string | No | `all` | `all`, `owner`, or `dealer` |
| `directUrls` | array | For direct mode | - | Public Craigslist listing URLs |
| `minPrice` / `maxPrice` | integer | No | - | Price range filters |
| `minBedrooms` | integer | No | - | Minimum visible bedroom count |
| `postalCode` | string | No | - | ZIP/postal code for radius search |
| `searchDistance` | integer | No | `10` | Radius in miles when `postalCode` is provided |
| `maxListings` | integer | No | `25` | Result cap from 1 to 500 |
| `includePhotos` | boolean | No | `true` | Include public image URLs |
| `includeContactInfo` | boolean | No | `false` | Extract only public phone/email strings visible in listing text |

### Input / Output

Example input:

```json
{
  "mode": "search",
  "city": "sfbay",
  "category": "rea",
  "listingType": "owner",
  "minPrice": 200000,
  "maxPrice": 900000,
  "minBedrooms": 2,
  "maxListings": 25,
  "includePhotos": true,
  "includeContactInfo": true
}
```

Example output:

```json
{
  "url": "https://sfbay.craigslist.org/sfc/rea/d/san-francisco-condo/1234567890.html",
  "title": "2BR Condo For Sale By Owner",
  "price": 825000,
  "bedrooms": 2,
  "bathrooms": 1,
  "sqft": 950,
  "location": "Mission District",
  "posting_date": "2026-06-26T15:30:00-0700",
  "photos": ["https://images.craigslist.org/00a0a_example_600x450.jpg"],
  "body": "Charming 2 bedroom condo with hardwood floors...",
  "attributes": ["2br", "1ba", "950ft2"],
  "by_owner": true,
  "housing_type": "condo",
  "contact_available": true,
  "phone_numbers": ["(415) 555-0100"],
  "emails": [],
  "scraped_at": "2026-07-11T11:30:00Z"
}
```

Download the dataset in JSON, HTML, CSV, or Excel, or access it through the [Apify API](https://docs.apify.com/api/v2).

### Use cases

- FSBO lead research: find public for-sale-by-owner listings before they move to other channels.
- Rental market monitoring: compare rents, amenities, and available supply across neighborhoods.
- Investor sourcing: watch Craigslist real estate for owner-posted properties, land, and small deals.
- Property management research: monitor rooms, sublets, apartments, and vacation rental patterns.
- Data enrichment: feed listing URLs, prices, descriptions, and public contact signals into spreadsheets, CRMs, dashboards, or internal tools.

### How much does it cost to scrape Craigslist real estate listings?

This actor uses pay-per-event pricing. One event is one matching Craigslist real estate listing pushed to the dataset. Apify account credits or free trial credits may cover small test runs depending on your account.

| Tier | Event | Price per event | Price per 1,000 listings |
|------|-------|-----------------|--------------------------|
| Free, Bronze, Silver | `real-estate-listing-scraped` | $0.00299 | **$2.99** |
| Gold | `real-estate-listing-scraped` | $0.00269 | **$2.69** |

For example, collecting 100 matching listings costs about $0.30 on Free, Bronze, or Silver, before any account-level credits.

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("parsebird/craigslist-real-estate-scraper").call(run_input={
    "mode": "search",
    "city": "sfbay",
    "category": "rea",
    "listingType": "owner",
    "minPrice": 200000,
    "maxPrice": 900000,
    "minBedrooms": 2,
    "maxListings": 25,
    "includePhotos": True,
    "includeContactInfo": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["url"])
```

### JavaScript API example

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

const client = new ApifyClient({ token: "YOUR_APIFY_TOKEN" });

const run = await client.actor("parsebird/craigslist-real-estate-scraper").call({
  mode: "search",
  city: "sfbay",
  category: "rea",
  listingType: "owner",
  minPrice: 200000,
  maxPrice: 900000,
  minBedrooms: 2,
  maxListings: 25,
  includePhotos: true,
  includeContactInfo: true
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const item of items) {
  console.log(`${item.title} - ${item.price} - ${item.url}`);
}
```

### Is it legal to scrape Craigslist real estate listings?

This actor extracts public Craigslist listing data. Use it responsibly, respect Craigslist's terms, do not misuse personal data, and make sure your use case complies with applicable laws and regulations. For general background, read Apify's guide: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

### Other Craigslist scrapers / Related Actors

- [Craigslist Scraper](https://apify.com/parsebird/craigslist-scraper) - broader Craigslist categories including cars, jobs, services, and for-sale listings.
- [Propertyfinder Scraper](https://apify.com/parsebird/propertyfinder-scraper) - real estate listing data from Property Finder.
- [Funda Scraper](https://apify.com/parsebird/funda-scraper) - Netherlands real estate listings.
- [Fotocasa Scraper](https://apify.com/parsebird/fotocasa-scraper) - Spanish real estate listings.
- [BusinessesForSale Listings Scraper](https://apify.com/parsebird/businessesforsale-listings-scraper) - business acquisition listings and contact URLs.

### FAQ

**Can I scrape Craigslist FSBO listings?**
Yes. Set `listingType` to `owner`. The actor keeps listings only when Craigslist category codes or visible text indicate owner/FSBO status.

**Does the actor collect hidden Craigslist reply emails?**
No. `includeContactInfo` extracts only phone numbers or emails visible in the public listing body. It does not automate Craigslist reply flows.

**Can I scrape rentals as well as homes for sale?**
Yes. Use `apa` for apartments, `roo` for rooms, `sub` for sublets, `vac` for vacation rentals, and `rea` for real estate for sale.

**How do I find my Craigslist city code?**
Use the subdomain in the Craigslist URL. For example, `https://sfbay.craigslist.org/` uses `sfbay`.

**Can I schedule recurring Craigslist real estate runs?**
Yes. Use [Apify scheduling](https://docs.apify.com/platform/actors/running/schedules) to run the actor hourly, daily, weekly, or on a custom interval.

**Can I connect results to other tools?**
Yes. Use the Apify API, dataset webhooks, or [Apify integrations](https://apify.com/integrations) to send data to spreadsheets, databases, CRMs, Make, Zapier, n8n, or custom apps.

**Why are some fields empty?**
Craigslist listings vary by poster and city. If a listing does not show square footage, contact text, photos, or a posted timestamp publicly, that field may be empty.

**Where can I report issues?**
Open an issue on the actor's Issues tab or contact ParseBird from the Apify Console with the city, category, input, and an example listing URL.

### Legal and compliance

Craigslist Real Estate Scraper | FSBO Listings & Rentals is designed for public listing research, monitoring, and analysis. Review the source site's terms, handle personal data carefully, and use the exported JSON, CSV, Excel, API, and integration workflows only for compliant purposes.

# Actor input Schema

## `mode` (type: `string`):

Choose search to build a Craigslist city search, or direct URLs to scrape exact public listing pages.

## `city` (type: `string`):

Craigslist city code. Use the subdomain from craigslist.org, such as sfbay, newyork, losangeles, or chicago.

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

Craigslist real estate category to scrape.

## `listingType` (type: `string`):

Filter for owner/FSBO or dealer/broker where Craigslist exposes that signal. The scraper also applies post-fetch checks to listing URLs, category codes, and text.

## `directUrls` (type: `array`):

Paste public Craigslist real estate listing URLs. Used only when mode is direct\_urls.

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

Only include listings priced at or above this amount.

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

Only include listings priced at or below this amount.

## `minBedrooms` (type: `integer`):

Only include listings with at least this many bedrooms when the field is visible.

## `postalCode` (type: `string`):

Optional ZIP/postal code for Craigslist radius search.

## `searchDistance` (type: `integer`):

Radius in miles around the postal code. Used only when postal code is provided.

## `maxListings` (type: `integer`):

Hard cap on listings to return. Allowed range is 1 to 500.

## `includePhotos` (type: `boolean`):

Return public Craigslist image URLs when available.

## `includeContactInfo` (type: `boolean`):

Extract only phone numbers or emails visibly present in the public listing body. The actor does not automate Craigslist reply flows.

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

Use Apify Proxy for reliable Craigslist requests. Switch proxy groups if Craigslist returns blocks or empty responses.

## Actor input object example

```json
{
  "mode": "search",
  "city": "sfbay",
  "category": "rea",
  "listingType": "all",
  "directUrls": [
    "https://sfbay.craigslist.org/sfc/rea/d/san-francisco-example/1234567890.html"
  ],
  "searchDistance": 10,
  "maxListings": 25,
  "includePhotos": true,
  "includeContactInfo": true,
  "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 = {
    "mode": "search",
    "city": "sfbay",
    "category": "rea",
    "listingType": "all",
    "directUrls": [
        "https://sfbay.craigslist.org/sfc/rea/d/san-francisco-example/1234567890.html"
    ],
    "maxListings": 25,
    "includePhotos": true,
    "includeContactInfo": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/craigslist-real-estate-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 = {
    "mode": "search",
    "city": "sfbay",
    "category": "rea",
    "listingType": "all",
    "directUrls": ["https://sfbay.craigslist.org/sfc/rea/d/san-francisco-example/1234567890.html"],
    "maxListings": 25,
    "includePhotos": True,
    "includeContactInfo": True,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/craigslist-real-estate-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 '{
  "mode": "search",
  "city": "sfbay",
  "category": "rea",
  "listingType": "all",
  "directUrls": [
    "https://sfbay.craigslist.org/sfc/rea/d/san-francisco-example/1234567890.html"
  ],
  "maxListings": 25,
  "includePhotos": true,
  "includeContactInfo": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call parsebird/craigslist-real-estate-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Real Estate Scraper | FSBO & Rentals",
        "description": "Extract Craigslist real estate listings: prices, beds, baths, square footage, photos, descriptions, owner/dealer flags, and public contact signals. Search cities or paste listing URLs. Export as JSON, CSV, Excel.",
        "version": "1.0",
        "x-build-id": "boHjisnh7qTwInFaN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parsebird~craigslist-real-estate-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parsebird-craigslist-real-estate-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-real-estate-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parsebird-craigslist-real-estate-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-real-estate-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parsebird-craigslist-real-estate-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "direct_urls"
                        ],
                        "type": "string",
                        "description": "Choose search to build a Craigslist city search, or direct URLs to scrape exact public listing pages.",
                        "default": "search"
                    },
                    "city": {
                        "title": "City",
                        "enum": [
                            "sfbay",
                            "newyork",
                            "losangeles",
                            "chicago",
                            "seattle",
                            "boston",
                            "washingtondc",
                            "atlanta",
                            "dallas",
                            "houston",
                            "denver",
                            "philadelphia",
                            "miami",
                            "austin",
                            "sandiego",
                            "phoenix",
                            "portland",
                            "minneapolis",
                            "detroit",
                            "nashville",
                            "raleigh",
                            "charlotte",
                            "baltimore",
                            "stlouis",
                            "orlando",
                            "tampa",
                            "lasvegas",
                            "sacramento",
                            "newhaven",
                            "providence",
                            "richmond",
                            "saltlakecity",
                            "toronto",
                            "vancouver",
                            "montreal"
                        ],
                        "type": "string",
                        "description": "Craigslist city code. Use the subdomain from craigslist.org, such as sfbay, newyork, losangeles, or chicago.",
                        "default": "sfbay"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "apa",
                            "rea",
                            "roo",
                            "sub",
                            "vac"
                        ],
                        "type": "string",
                        "description": "Craigslist real estate category to scrape.",
                        "default": "rea"
                    },
                    "listingType": {
                        "title": "Listing type",
                        "enum": [
                            "all",
                            "owner",
                            "dealer"
                        ],
                        "type": "string",
                        "description": "Filter for owner/FSBO or dealer/broker where Craigslist exposes that signal. The scraper also applies post-fetch checks to listing URLs, category codes, and text.",
                        "default": "all"
                    },
                    "directUrls": {
                        "title": "Direct URLs",
                        "type": "array",
                        "description": "Paste public Craigslist real estate listing URLs. Used only when mode is direct_urls.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or above this amount."
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include listings priced at or below this amount."
                    },
                    "minBedrooms": {
                        "title": "Minimum bedrooms",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Only include listings with at least this many bedrooms when the field is visible."
                    },
                    "postalCode": {
                        "title": "Postal code",
                        "type": "string",
                        "description": "Optional ZIP/postal code for Craigslist radius search."
                    },
                    "searchDistance": {
                        "title": "Search distance",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Radius in miles around the postal code. Used only when postal code is provided.",
                        "default": 10
                    },
                    "maxListings": {
                        "title": "Max listings",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on listings to return. Allowed range is 1 to 500.",
                        "default": 25
                    },
                    "includePhotos": {
                        "title": "Include photos",
                        "type": "boolean",
                        "description": "Return public Craigslist image URLs when available.",
                        "default": true
                    },
                    "includeContactInfo": {
                        "title": "Include public contact info",
                        "type": "boolean",
                        "description": "Extract only phone numbers or emails visibly present in the public listing body. The actor does not automate Craigslist reply flows.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy for reliable Craigslist requests. Switch proxy groups if Craigslist returns blocks or empty responses.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
