# Craigslist Scraper (`automation-lab/craigslist-scraper`) Actor

Scrape Craigslist listings across any US city and category: for sale, housing, jobs, gigs, and services. Extracts titles, prices, locations, descriptions, and images. Supports price filtering and multi-query searches. Perfect for market research. Export to JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/craigslist-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 176 total users, 22 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 1.00 out of 5 stars

## Pricing

from $1.20 / 1,000 listing scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### What does Craigslist Scraper do?

Craigslist Scraper extracts listing data from **Craigslist searches or direct listing URLs** across any US city. Search one or many cities in a single run by keyword and category — for sale, housing, jobs, services, gigs, community — or enrich saved listing links without reconstructing a search. Optionally follow search results to get full descriptions, images, posting dates, and item attributes.

Use it for **market research**, **price comparison**, **lead generation**, **inventory sourcing**, and **local market analysis**.

### Use cases

### Who is it for?

Craigslist Scraper is for marketplace analysts, local lead-generation teams, real estate researchers, resellers, recruiters, and developers who need repeatable Craigslist data exports across cities and categories.

- **Price comparison** — Compare prices for used goods, electronics, furniture, or vehicles across different Craigslist cities and regions.
- **Inventory sourcing** — Find products to resell by scanning for underpriced items in for-sale categories.
- **Rental market research** — Monitor housing listings to analyze rent prices, availability, and trends in specific neighborhoods.
- **Job market analysis** — Track job postings by keyword to understand local hiring trends and salary ranges.
- **Lead generation** — Find service providers, contractors, or freelancers in specific cities and categories.
- **Local market intelligence** — Analyze listing volumes and prices to understand supply/demand in any metro area.

### Why use Craigslist Scraper?

- **Native multi-city search** — Search one or many Craigslist subdomains in a single run: newyork, sfbay, losangeles, chicago, seattle, and hundreds more.
- **All categories** — For sale, housing, jobs, services, gigs, and community.
- **Fast and lightweight** — Pure HTTP extraction with Cheerio. No browser needed. Gets 300+ listings per search in seconds.
- **Optional detail enrichment** — Enable `includeDetails` to follow each listing URL and get full descriptions, images, posting dates, and item attributes.
- **Price filtering** — Filter by minimum and maximum price to narrow results.
- **Direct listing URLs** — Submit saved Craigslist links to extract their full details without recreating the original search.
- **Multiple search queries** — Run several keyword searches in a single run.
- **Clean structured data** — Every listing includes title, price, location, URL, and more.
- **Pay-per-event pricing** — You only pay for listings scraped. No monthly subscription.

### What data can you extract?

Each listing in the output includes:

| Field | Description |
|-------|-------------|
| `listingId` | Craigslist listing ID |
| `title` | Listing title |
| `price` | Price as displayed (e.g., "$200") |
| `priceNumeric` | Price as a number (e.g., 200) |
| `location` | Neighborhood or area within the city |
| `city` | Craigslist city/region (e.g., "newyork", "sfbay") |
| `category` | Category searched (e.g., "for\_sale") |
| `url` | Direct link to the listing |
| `description` | Full listing description (when `includeDetails` is enabled) |
| `postedAt` | Posting date/time as ISO string (when `includeDetails` is enabled) |
| `imageCount` | Number of images (when `includeDetails` is enabled) |
| `imageUrls` | Array of image URLs (when `includeDetails` is enabled) |
| `latitude` | Latitude coordinate (when `includeDetails` is enabled) |
| `longitude` | Longitude coordinate (when `includeDetails` is enabled) |
| `address` | Street address (when `includeDetails` is enabled) |
| `bedrooms` | Bedrooms/bathrooms (housing, when `includeDetails` is enabled) |
| `sqft` | Square footage (housing, when `includeDetails` is enabled) |
| `condition` | Item condition (for-sale, when `includeDetails` is enabled) |
| `scrapedAt` | ISO timestamp of when data was collected |

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

This Actor uses **pay-per-event** pricing — you pay only for what you scrape. No monthly subscription. All platform costs (compute, proxy, storage) are **included**.

For unlimited or very large result runs, set **Maximum charge per run** before starting. This actor now respects PPE exhaustion and stops additional queries once the budget cap is reached.

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---:|---:|---:|---:|---:|---:|
| Actor start | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 | $0.001 |
| Per listing | $0.0023 | $0.002 | $0.00156 | $0.0012 | $0.0008 | $0.00056 |

The total actor charge is the one-time actor-start event plus the applicable per-listing rate multiplied by the number of listings saved. Check the live pricing panel before a large run because Apify may update prices or plan tiers. Apify platform credits are separate from these actor charges.

### How to scrape Craigslist

1. Click **Try for free** to open the Actor in Apify Console.
2. Enter one or more search keywords (e.g., "laptop", "bicycle").
3. Enter one city in `city`, or add several subdomains to `cities` (e.g., "newyork", "sfbay", "losangeles").
4. Select a category (For Sale, Housing, Jobs, etc.).
5. Optionally enable **Include listing details** for full descriptions and images.
6. Click **Start** and wait for the run to finish.
7. Download your data as JSON, CSV, or Excel from the **Dataset** tab.

**Direct URL example:**

```json
{
    "listingUrls": [
        "https://newyork.craigslist.org/brk/sys/d/brooklyn-laptop/7916291766.html"
    ]
}
```

**Multi-city search example:**

```json
{
    "searchQueries": ["laptop", "macbook"],
    "cities": ["newyork", "sfbay", "losangeles"],
    "category": "for_sale",
    "maxResults": 50,
    "includeDetails": true,
    "minPrice": 100,
    "maxPrice": 1000
}
```

`maxResults` applies to each query/city pair, so this example can return up to 300 unique listings (2 queries × 3 cities × 50). Duplicate listing IDs are emitted only once across the run. When `cities` contains values it overrides `city`; existing single-city inputs remain compatible.

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQueries` | array | `[]` | Keywords to search on Craigslist. If both this and `listingUrls` are empty, the Actor browses the selected category. |
| `listingUrls` | array | `[]` | Direct Craigslist listing URLs to enrich; invalid individual URLs are skipped. |
| `city` | string | "newyork" | Legacy-compatible single Craigslist city subdomain, used when `cities` is empty |
| `cities` | array | `[]` | Optional Craigslist city subdomains to search in one run; overrides `city`, normalizes case/spacing, rejects unsafe values, and removes duplicates |
| `category` | string | "for\_sale" | Category: for\_sale, housing, jobs, services, gigs, community |
| `maxResults` | integer | 100 | Maximum listings per query per city; run-wide duplicate listing IDs are omitted |
| `includeDetails` | boolean | false | Follow each listing for full description, images, and attributes |
| `minPrice` | integer | — | Minimum price filter |
| `maxPrice` | integer | — | Maximum price filter |
| `maxRequestRetries` | integer | 3 | Retry attempts for failed requests (1–10) |

### Output example

```json
{
    "listingId": "7916291766",
    "title": "Dell Inspiron notebook laptop computer",
    "price": "$200",
    "priceNumeric": 200,
    "location": "Brooklyn",
    "city": "newyork",
    "category": "for_sale",
    "url": "https://newyork.craigslist.org/brk/sys/d/brooklyn-dell-inspiron-notebook-laptop/7916291766.html",
    "description": "Very good condition and seldom taken out of the house...",
    "postedAt": "2026-02-19T18:13:00-0500",
    "imageCount": 2,
    "imageUrls": [
        "https://images.craigslist.org/00505_6GdwfDeDqEP_0t20CI_600x450.jpg",
        "https://images.craigslist.org/00r0r_75O90wuRsu3_0t20CI_600x450.jpg"
    ],
    "latitude": 40.6782,
    "longitude": -73.9442,
    "address": "123 Flatbush Ave",
    "bedrooms": "",
    "sqft": "",
    "condition": "excellent",
    "scrapedAt": "2026-03-03T00:11:52.977Z"
}
```

### Tips for best results

- **Start without details** — Basic mode scrapes 300+ listings in seconds. Enable `includeDetails` only when you need descriptions and images.
- **Use specific keywords** — "macbook pro m3" returns better results than just "laptop".
- **Compare cities in one run** — Add popular subdomains such as newyork, sfbay, losangeles, chicago, seattle, boston, denver, austin, miami, and portland to `cities`.
- **Filter by price** — Use `minPrice` and `maxPrice` to narrow results to your target range.
- **Schedule regular runs** — Use [Apify Schedules](https://docs.apify.com/platform/schedules) for daily monitoring of new listings.
- **Combine categories** — Run separate searches for "for\_sale" and "housing" to build a comprehensive local market dataset.
- **Multiple keywords per run** — Add several keywords to `searchQueries` for efficient batch scraping.

### Integrations

Connect Craigslist Scraper to your existing tools and workflows:

- [**Google Sheets**](https://apify.com/integrations/google-sheets) — Export scraped data directly to Google Sheets.
- [**Zapier**](https://apify.com/integrations/zapier) — Trigger actions in 5,000+ apps when new listings are found.
- [**Make (Integromat)**](https://apify.com/integrations/make) — Build automated workflows with scraped Craigslist data.
- [**Slack**](https://apify.com/integrations/slack) — Get notified when new listings match your criteria.
- [**Webhooks**](https://docs.apify.com/platform/integrations/webhooks) — Send data to your own API endpoint after each run.
- [**Apify API**](https://docs.apify.com/api/v2) — Programmatically start runs and retrieve results.
- [**Craigslist → Google Sheets rental tracker**](https://apify.com/integrations/google-sheets) — Schedule daily housing scrapes and auto-append to a spreadsheet to track rent prices and availability over time.
- [**Craigslist → Slack new listing alerts**](https://apify.com/integrations/slack) — Get notified instantly when new listings match your search criteria — great for competitive markets where listings go fast.

### API usage

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/craigslist-scraper').call({
    searchQueries: ['laptop'],
    city: 'newyork',
    maxResults: 50,
    includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/craigslist-scraper').call(run_input={
    'searchQueries': ['laptop'],
    'city': 'newyork',
    'maxResults': 50,
    'includeDetails': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Craigslist cities

Popular city subdomains you can use:

| City | Subdomain | | City | Subdomain |
|------|-----------|---|------|-----------|
| New York | `newyork` | | San Francisco | `sfbay` |
| Los Angeles | `losangeles` | | Chicago | `chicago` |
| Seattle | `seattle` | | Boston | `boston` |
| Denver | `denver` | | Austin | `austin` |
| Miami | `miami` | | Portland | `portland` |
| Dallas | `dallas` | | Atlanta | `atlanta` |
| Phoenix | `phoenix` | | Minneapolis | `minneapolis` |
| Philadelphia | `philadelphia` | | Washington DC | `washingtondc` |

For a complete list of cities, visit [craigslist.org/about/sites](https://www.craigslist.org/about/sites).

**cURL:**

```bash
curl "https://api.apify.com/v2/acts/automation-lab~craigslist-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{
    "searchQueries": ["apartment"],
    "city": "sfbay",
    "category": "housing",
    "maxResults": 50
  }'
```

#### RSS feed export for saved-search alerts

For scheduled Craigslist saved-search alerts, create an Apify task and export the latest run as RSS with Apify's positional `outputFields` mapping:

```text
https://api.apify.com/v2/actor-tasks/{TASK_ID}/runs/last/dataset/items?format=rss&fields=title,url,description,postedAt&outputFields=title,link,description,pubDate&token=YOUR_API_TOKEN
```

### Use with AI agents via MCP

Craigslist Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/craigslist-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=automation-lab/craigslist-scraper"
        }
    }
}
```

#### Example prompts

Once connected, try asking your AI assistant:

- "Search Craigslist SF for apartments under $2000/month"
- "Find used cars in Los Angeles on Craigslist"
- "Get all freelance gig postings in New York on Craigslist"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Legality

Scraping publicly available data is generally legal according to the [US Court of Appeals ruling](https://en.wikipedia.org/wiki/HiQ_Labs_v._LinkedIn) (HiQ Labs v. LinkedIn). This actor only accesses publicly available information and does not require authentication. Always review and comply with the target website's Terms of Service before scraping. For personal data, ensure compliance with GDPR, CCPA, and other applicable privacy regulations.

### FAQ

**How many listings can I scrape per search?**
Craigslist returns up to ~300-400 listings per search query. Use `maxResults` to limit the output.

**How fast is the scraper?**
Basic mode (no details) scrapes 300+ listings in 2-3 seconds. With `includeDetails` enabled, each listing takes about 1-2 seconds to fetch the detail page.

**Can I search multiple cities?**
Yes. Set `cities` to an array of Craigslist subdomains. Every keyword is searched in every selected city, results retain their source `city`, and duplicate listing IDs are returned only once.

**What categories are available?**
For Sale, Housing, Jobs, Services, Gigs, and Community. These cover the main Craigslist sections.

**Why are description and images empty?**
Enable the `includeDetails` option to fetch full descriptions, images, and posting dates from each listing's detail page. Basic mode only returns data from the search results page.

**Listings are missing or the scraper returns 0 results. What happened?**
Craigslist may temporarily block requests from certain IPs. The scraper uses automatic retries, but if you consistently get 0 results, try a different city or verify the keyword returns results on Craigslist directly. Very niche keywords may have no listings in some cities.

**Can I scrape multiple cities in one run?**
Yes. Use `cities`; the existing `city` input still works for single-city runs. Unsafe hostnames and URLs are never interpolated into Craigslist request hosts.

### How do I search Craigslist across multiple cities at once?

Pass the city subdomains in one Actor call:

```javascript
const run = await client.actor('automation-lab/craigslist-scraper').call({
    searchQueries: ['macbook pro'],
    cities: ['newyork', 'sfbay', 'losangeles', 'chicago', 'seattle'],
    category: 'for_sale',
    maxResults: 100,
});
```

The Actor fans every query out across the selected cities and writes one combined, deduplicated dataset. Schedule that single input for recurring cross-market price comparison or alerts.

### Can I set up alerts for new Craigslist listings?

Yes. Use a combination of scheduled runs and integrations to get real-time-like alerts:

1. Set up a **Schedule** in Apify Console to run the scraper every 15–60 minutes
2. Connect a **Webhook** that fires when each run finishes
3. In your webhook handler, compare new listings against previously seen IDs and filter for new ones
4. Push new listings to **Slack**, **email**, or any notification service via [Zapier](https://apify.com/integrations/zapier) or [Make](https://apify.com/integrations/make)

This pattern is popular for competitive markets like SF Bay Area rentals or limited-supply items where listings disappear within hours.

### Is Craigslist data useful for real estate market research?

Yes — Craigslist is one of the richest publicly available sources for local rental market data, particularly for smaller metros and informal listings not captured by Zillow or Apartments.com. Use the `housing` category to extract:

- **Rental price trends** by neighborhood and bedroom count (`bedrooms`, `sqft`, `priceNumeric`)
- **Supply analysis** — listing volumes by city and neighborhood
- **Geographic clustering** — latitude/longitude coordinates for mapping rental density
- **Seasonal patterns** — track pricing and availability changes month over month with scheduled runs

Enable `includeDetails: true` to get full descriptions, square footage, bedroom counts, and coordinates for each listing.

### How do I find underpriced items on Craigslist for resale?

The most effective approach is to search multiple cities for the same item, filter by price, and compare against known market values:

1. Set `searchQueries` to specific model names (e.g., "iphone 14 pro", "trek checkpoint")
2. Set `minPrice` and `maxPrice` to filter out unrealistic listings
3. Enable `includeDetails: true` for condition and full descriptions
4. Run across 5–10 cities and sort results by `priceNumeric` ascending

The `condition` field (excellent, good, fair) and `imageUrls` help quickly filter quality listings before reaching out.

### Related scrapers

- [Amazon Scraper](https://apify.com/automation-lab/amazon-scraper) -- Scrape Amazon product data, prices, and reviews.
- [eBay Scraper](https://apify.com/automation-lab/ebay-scraper) -- Scrape eBay listings, prices, and seller data.
- [Walmart Scraper](https://apify.com/automation-lab/walmart-scraper) -- Scrape Walmart product data, prices, and reviews.
- [Etsy Scraper](https://apify.com/automation-lab/etsy-scraper) -- Scrape Etsy product listings, seller data, and shop reviews.
- [Target Scraper](https://apify.com/automation-lab/target-scraper) -- Scrape Target product data and prices.
- [Shopify Scraper](https://apify.com/automation-lab/shopify-scraper) -- Scrape products from any Shopify store.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search on Craigslist. Each keyword runs a separate search. Leave empty to browse all listings in the selected category without keyword filtering.

## `listingUrls` (type: `array`):

Direct Craigslist listing URLs to enrich. Use this for saved links without reconstructing a keyword search. Invalid URLs are skipped safely.

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

Craigslist city subdomain used when Cities is empty. Examples: newyork, sfbay, losangeles, chicago.

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

Search every keyword/category in each Craigslist city subdomain. When provided, this overrides City. Values are normalized and duplicates are removed; unsafe values are rejected.

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

Craigslist category to search in.

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

Maximum listings for each keyword/city pair (or for each city when browsing without keywords). Duplicates across the run are omitted.

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

Follow each listing URL to get full description, images, posting date, and attributes. Slower but more data.

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

Minimum price filter. Leave empty for no minimum.

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

Maximum price filter. Leave empty for no maximum.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed requests.

## Actor input object example

```json
{
  "searchQueries": [
    "laptop"
  ],
  "listingUrls": [],
  "city": "newyork",
  "cities": [],
  "category": "for_sale",
  "maxResults": 20,
  "includeDetails": false,
  "minPrice": 100,
  "maxPrice": 1000,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all scraped Craigslist listings.

# 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 = {
    "searchQueries": [
        "laptop"
    ],
    "city": "newyork",
    "category": "for_sale",
    "maxResults": 20,
    "includeDetails": false,
    "minPrice": 100,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "searchQueries": ["laptop"],
    "city": "newyork",
    "category": "for_sale",
    "maxResults": 20,
    "includeDetails": False,
    "minPrice": 100,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/craigslist-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "laptop"
  ],
  "city": "newyork",
  "category": "for_sale",
  "maxResults": 20,
  "includeDetails": false,
  "minPrice": 100,
  "maxRequestRetries": 3
}' |
apify call automation-lab/craigslist-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/craigslist-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/1b2gJ9AWuxa5WWlOQ/builds/VjBbIPkqY0h7Eo3dm/openapi.json