# Craigslist Scraper - (Jobs & Listings etc.) (`khadinakbar/craigslist-all-in-one-scraper`) Actor

Scrape Craigslist classifieds across 700+ cities and all 8 categories (jobs, housing, for-sale, services, gigs, community, resumes, events). Typed outputs, multi-city fanout, repost dedup, optional contact extraction. MCP-ready. Pay-per-event.

- **URL**: https://apify.com/khadinakbar/craigslist-all-in-one-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** E-commerce, Automation, Lead generation
- **Stats:** 3 total users, 2 monthly users, 88.9% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Jobs, Housing, For-Sale, Services, Gigs (700+ cities)

**Scrape Craigslist classifieds across 700+ city subdomains and all 8 categories** — jobs, housing, for-sale, services, gigs, community, resumes, events — with **typed per-category outputs** (parsed salary, bed/bath/sqft, car make/model/year), **multi-city auto-fanout**, **cross-city repost deduplication**, and optional public contact extraction. Designed for **AI agents** (MCP-ready descriptions) and traditional pipelines alike. Pay-per-event, residential proxies included.

> Try it: pick a city subdomain (e.g. `newyork`), choose a category (`forsale`, `jobs`, `housing`, …), and run.

### What does this Craigslist scraper do?

This Actor extracts public Craigslist classified listings and returns them as a clean, **typed JSON dataset**:

- One row per listing with stable keys (`postId`, `title`, `url`, `city`, `priceText`, `priceNumeric`, `currency`, `postedAt`, `updatedAt`, `primaryImage`, `attributes`, `geo`, `contact`).
- **Typed per-category attributes** parsed out of Craigslist's HTML for you — no regex required:
  - **Jobs** → compensation, employment type, role, telecommute.
  - **Housing** → bedrooms, bathrooms, sqft, housing type, laundry, parking, available, pets-OK flags, furnished, smoking, wheelchair-accessible.
  - **Cars + trucks** → year, make, model, odometer, fuel type, transmission, title status, condition, drive type, cylinders, paint colour, VIN.
  - **General for-sale** → condition, seller type.
- **Multi-city auto-fanout** — pass `city: "topUSMetros"` to scrape the top 25 US metros in one run, `topGlobalMetros` for the top 50 worldwide, or supply your own `cities` list.
- **Cross-city repost deduplication** — when dealers and agencies repost the same listing in five cities, you get one row, not five.
- **Optional full post detail** (`includeDetails: true`) — fetches the full description, complete image gallery, parsed attribute groups, and reply URL.
- **Optional public contact extraction** (`extractContacts: true`) — pulls emails and phones that the poster placed in the public body. Never bypasses Craigslist's anonymized reply flow; never logs in.

The Actor is **MCP-ready**: every input field has a precise four-sentence description, the tool description names the use case and disambiguator, and the output schema is flat and ≤500 tokens per row — built for Claude, GPT, and other AI agents to call directly through the [Apify MCP integration](https://docs.apify.com/platform/integrations/mcp).

### Why use this Craigslist scraper?

- **Resellers and arbitrageurs** — track low-priced electronics, cars, tools, and tickets across multiple metros, deduplicated.
- **Recruiters** — pull fresh gigs and full-time postings in `jobs` and `gigs` with parsed compensation.
- **Real-estate teams** — aggregate `apartments`, `rooms`, `sublets`, and `real-estate-for-sale` postings with parsed bed/bath/sqft.
- **Service-business operators** — monitor competitor activity across `services`.
- **Market researchers** — observe supply-side trends in goods, jobs, and rentals across cities.
- **AI agents** — call this Actor as a tool over MCP for ad-hoc classifieds research, comp pricing, lead generation.

Apify advantages: scheduled runs, dataset export (JSON/CSV/Excel/HTML/RSS), webhook integrations, residential proxy rotation, run history, retry logic, and a managed cloud runtime.

### How to use the Craigslist scraper

1. **Pick your city.** Use a single Craigslist subdomain such as `newyork`, `sfbay`, `losangeles`, `london`, or `toronto`. Or use a preset: `topUSMetros` (top 25 US metros) or `topGlobalMetros` (top 50 worldwide). Or pass a `cities` array of subdomains.
2. **Choose a category.** `forsale` (default), `jobs`, `housing`, `services`, `community`, `gigs`, `resumes`, `events`, or `all`.
3. **(Optional) narrow with a subcategory code.** `cta` for cars+trucks, `apa` for apartments, `sof` for software jobs, etc. — full list below.
4. **(Optional) add a search query.** Free text — for example `macbook pro`, `studio apartment`, `remote python`.
5. **(Optional) set price/age/picture filters.** `minPrice`, `maxPrice`, `maxAgeDays`, `hasPic`, `ownerOnly`.
6. **Choose detail depth.** Leave `includeDetails: false` (default) for the cheap search-card path ($0.005/listing). Set `includeDetails: true` to also fetch full descriptions, complete galleries, and reply URLs ($0.008/listing).
7. **Save and run.** Apify spins up the Actor, rotates residential proxies, paginates Craigslist, deduplicates reposts, and writes a clean dataset.

### Input

| Field | Type | Description |
|---|---|---|
| `city` | string | Craigslist city subdomain (e.g. `newyork`, `sfbay`). Or preset `topUSMetros` / `topGlobalMetros`. |
| `cities` | array of strings | Multiple city subdomains. Overrides `city` when set. |
| `category` | enum | `forsale`, `jobs`, `housing`, `services`, `community`, `gigs`, `resumes`, `events`, `all`. |
| `subcategory` | string | 3-letter Craigslist subcategory code (e.g. `cta`, `apa`, `sof`). |
| `searchQuery` | string | Free-text search inside the chosen category. |
| `startUrls` | array | Direct Craigslist URLs. Overrides `city`/`category`/`searchQuery`. |
| `maxResults` | int | Max listings per city. Default 50. Hard ceiling 3000 per city. |
| `includeDetails` | bool | Fetch full post details. Default `false`. |
| `extractContacts` | bool | Extract public emails/phones from post body. Requires `includeDetails`. Default `false`. |
| `minPrice` / `maxPrice` | int | Price filters in the listing's local currency. |
| `hasPic` | bool | Only listings with at least one image. |
| `ownerOnly` | bool | Exclude dealer/agency/recruiter posts. |
| `maxAgeDays` | int | Skip listings older than this many days. |
| `dedupAcrossCities` | bool | Drop second occurrence of the same repost across cities. Default `true`. |
| `proxyConfiguration` | object | Apify Proxy settings. Residential strongly recommended. |

Example input (top 5 US metros, used MacBooks, with pictures, under $1500):

```json
{
  "city": "topUSMetros",
  "category": "forsale",
  "subcategory": "ela",
  "searchQuery": "macbook pro",
  "maxPrice": 1500,
  "hasPic": true,
  "ownerOnly": true,
  "maxResults": 100,
  "includeDetails": true,
  "dedupAcrossCities": true
}
````

### Output

The Actor pushes one row per listing into the default dataset. Sample (truncated):

```json
{
  "postId": "7708131934",
  "title": "MacBook Pro 14\" M2 Pro 16GB 512GB Space Gray",
  "url": "https://newyork.craigslist.org/mnh/sys/d/new-york-macbook-pro-14-m2-pro-16gb/7708131934.html",
  "city": "newyork",
  "cityLabel": "New York",
  "category": "forsale",
  "subcategory": "sys",
  "neighborhood": "Upper East Side",
  "priceText": "$1,450",
  "priceNumeric": 1450,
  "currency": "USD",
  "postedAt": "2026-05-13T09:14:00.000Z",
  "updatedAt": "2026-05-13T09:14:00.000Z",
  "primaryImage": "https://images.craigslist.org/00808_xxxxx_600x450.jpg",
  "images": ["https://images.craigslist.org/...", "..."],
  "description": "Selling my 14-inch MacBook Pro M2 Pro, 16GB unified memory, 512GB SSD…",
  "attributes": {
    "condition": "excellent",
    "make_/_manufacturer": "Apple",
    "model_name_/_number": "MacBook Pro M2 Pro"
  },
  "geo": { "lat": 40.7736, "lng": -73.9566 },
  "address": null,
  "contact": {
    "replyUrl": "https://newyork.craigslist.org/reply/nyc/sys/7708131934"
  },
  "isOwnerPost": true,
  "fingerprint": "9c7a…",
  "scrapedAt": "2026-05-13T09:18:42.103Z"
}
```

You can download the dataset in JSON, CSV, Excel, HTML, or RSS from the Apify Console **Storage → Dataset** tab.

### Data fields

| Field | Type | Description |
|---|---|---|
| `postId` | string | Craigslist post ID (stable across edits). |
| `title` | string | Post title. |
| `url` | string | Canonical URL on the city subdomain. |
| `city` / `cityLabel` | string | Craigslist subdomain and human label. |
| `category` / `subcategory` | string | Top-level category + 3-letter subcategory code. |
| `neighborhood` | string | Sub-area shown on the post. |
| `priceText` / `priceNumeric` / `currency` | mixed | Raw price + parsed numeric + ISO 4217 code. |
| `postedAt` / `updatedAt` | ISO 8601 | UTC timestamps. |
| `primaryImage` | string | URL of the search-card thumbnail. |
| `images` | array | All gallery images (detailed mode). |
| `description` | string | Full post body (detailed mode). |
| `attributes` | object | Typed per-category attributes — see below. |
| `geo` | object | `{ lat, lng }` when the post has a map. |
| `address` | string | Approximate address when shown. |
| `contact` | object | `{ replyUrl, email?, phone? }`. Public-only. |
| `isOwnerPost` | bool | True/false when the post explicitly states; otherwise `null`. |
| `fingerprint` | string | SHA-256 dedup hash. |
| `scrapedAt` | ISO 8601 | When this row was scraped. |

#### Typed attributes by category

- **Jobs:** `compensation`, `employment_type`, `job_title`, `telecommute_ok`.
- **Housing:** `bedrooms`, `bathrooms`, `sqft`, `housing_type` (apartment/house/condo/loft/townhouse), `laundry`, `parking`, `available`, `cats_are_ok`, `dogs_are_ok`, `furnished`, `no_smoking`, `wheelchair_accessible`.
- **Cars + trucks:** `year`, `make`, `model`, `odometer`, `fuel`, `transmission`, `title_status`, `condition`, `drive`, `cylinders`, `paint_color`, `vin`.
- **General for-sale:** `condition`, `make_/_manufacturer`, `model_name_/_number`, `size_/_dimensions`.

#### Subcategory codes (quick reference)

| Category | Codes |
|---|---|
| For-sale | `sss` (all), `cta`/`cto`/`ctd` (cars+trucks), `mca` (motorcycles), `ela`/`sys`/`cmp`/`pho`/`vid` (electronics + computers + phones + photo + video), `fua`/`hsh`/`app` (furniture + household + appliances), `bia`/`tla`/`spo`/`toy` (bikes + tools + sport + toys), `clo`/`jwl`/`bab` (clothing + jewelry + baby), `art`/`boo`/`col`/`mus` (arts/books/collectibles/music), `gar` (garage sale), `mat` (materials), `tic` (tickets), `wan` (wanted) |
| Jobs | `sof` (software), `web` (web/info-design), `acc` (accounting), `med` (medical), `wri` (writing), `sad` (sales), `mar` (marketing), `csr` (customer service), `egr` (engineering), `tch` (tech support), `lgl` (legal), `mnu` (manufacturing), `npo` (nonprofit), `sci` (science), `bus` (business), `edu` (education), `fbh` (food/bev), `gov` (government), `hum` (HR), `prk` (trades) |
| Housing | `apa` (apartments), `roo` (rooms), `sub` (sublets), `rea` (real-estate-for-sale), `pak` (parking/storage), `off` (office), `vac` (vacation), `swp` (housing-swap) |
| Services | `aos` (auto), `bts` (beauty), `cps` (computer), `crs` (creative), `cys` (cycle), `evs` (event), `fns` (financial), `hss` (household), `lbs` (labor), `lgs` (legal), `lss` (lessons), `mas` (marine), `pas` (pet), `pes` (real-estate-svc), `sks` (skilled trades), `wet` (writing), `wrs` (write/edit) |
| Gigs | `cpg`, `crg`, `dmg`, `evg`, `lbg`, `tlg`, `wrg` |

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

Pay-per-event. Two billable events plus a small actor-start charge:

| Event | Price | When charged |
|---|---:|---|
| `actor-start` | $0.00005 | Once per run, per GB of memory. |
| `listing-scraped` | **$0.005** / listing | Search-card mode (default). Returns title, price, location, primary image, posted date, URL. |
| `listing-detailed` | **$0.008** / listing | Full post mode (`includeDetails: true`). Returns description, full gallery, typed attributes, reply URL. |

**Typical run costs** (excluding the negligible start fee):

- 50 listings, search-card → **$0.25**
- 50 listings, detailed → **$0.40**
- 500 listings across top 5 US metros, search-card → **$2.50**
- 500 listings across top 5 US metros, detailed → **$4.00**

**Pay-Per-Usage** (compute + proxy passthrough) is also available — pick whichever model your run profile prefers in Apify Console.

### Tips and advanced options

- **Start narrow, then widen.** Set `maxResults: 25` for your first run to validate selectors, then scale up.
- **Use search-card mode for monitoring, detailed mode for enrichment.** Card mode is 1.6× cheaper and 4× faster.
- **Multi-metro dedup pays for itself.** Resellers reposting the same item across 10 metros routinely cut output volume by 60% with `dedupAcrossCities: true`.
- **Respect the age filter.** `maxAgeDays: 7` stops pagination once a page becomes mostly stale — saves money on long-running monitoring schedules.
- **Residential proxies are recommended.** Craigslist rate-limits datacenter IPs aggressively; the actor defaults to Apify residential proxies.
- **Schedule it.** Apify Scheduler can run the actor every N minutes/hours with the same input — ideal for "watch this search" use cases.

### FAQ, disclaimers, and support

**Is scraping Craigslist legal?** Public-data scraping is generally lawful in the US (see *hiQ Labs v. LinkedIn*), but Craigslist has aggressively pursued bulk scrapers and aggregators in past litigation (*craigslist v. 3Taps*, *RadPad*, *Instamotor*). This Actor only retrieves publicly visible classifieds, never logs in, never bypasses Craigslist's anonymized reply form, and respects standard rate limits. **You are responsible for ensuring your use complies with Craigslist's Terms of Service and any applicable local law.** Do not use this Actor to repost Craigslist content elsewhere, build a Craigslist-clone aggregator, or contact posters at scale.

**Why are some posts missing?** Craigslist sometimes serves a CAPTCHA when it suspects automation. The actor rotates residential proxies and a session pool, and retries with backoff, but a small percentage of posts may still be skipped. The `RUN_SUMMARY` key in the Key-Value Store lists all warnings.

**Why is `priceNumeric` null sometimes?** When the post says "please contact" or has no price column for that category. The raw `priceText` is preserved.

**Why didn't `extractContacts` find an email?** Craigslist hides contact info behind its anonymized reply form by default. The actor only extracts emails and phones that the *poster* placed in the public body. The anonymized `replyUrl` is always available.

**Can it scrape behind Craigslist accounts?** No. This actor never logs in.

**Where do I report bugs or feature requests?** Use the **Issues** tab on the Actor's Apify Store page. We respond to every issue. Custom-output, scheduled-monitor, and Webhook-on-new-post variants are available — contact the publisher.

### Related actors

If you're scraping classifieds at scale, you may also want:

- [Zillow All-in-One Scraper](https://apify.com/khadinakbar/zillow-all-in-one-scraper) — Zillow properties + sold history.
- [Idealista Scraper](https://apify.com/khadinakbar/idealista-scraper) — European real-estate listings.
- [B2B Lead Finder + Enrichment](https://apify.com/khadinakbar/b2b-lead-finder-enrichment) — Google Maps leads with email enrichment.
- [Email Address Validator](https://apify.com/khadinakbar/email-address-validator) — clean the contacts you extract.
- [LinkedIn Jobs Scraper](https://apify.com/khadinakbar/linkedin-jobs-scraper) — jobs from LinkedIn for cross-source coverage.

# Actor input Schema

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

Craigslist city subdomain to scrape (e.g. 'newyork', 'sfbay', 'losangeles', 'london'). Find the value in any Craigslist URL: the part before '.craigslist.org'. Use the preset 'topUSMetros' to fan out across the top 25 US metros, or 'topGlobalMetros' for the top 50 worldwide. Ignored when 'cities' or 'startUrls' is set.

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

List of Craigslist city subdomains to scrape in one run (e.g. \['newyork','sfbay','losangeles']). Each subdomain produces an independent search. Leave empty to use the single 'city' field. NOT free-text city names — use the subdomain values.

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

Top-level Craigslist category. 'forsale' covers all goods (cars+trucks, electronics, furniture, etc.); pick a 'subcategory' below for narrower results. Defaults to 'forsale'. Use 'all' to scrape every category (expensive — leaves volume control to 'maxResults').

## `subcategory` (type: `string`):

Craigslist subcategory code that narrows the category (e.g. 'cta' for cars+trucks-all, 'apa' for apartments/housing, 'sof' for software jobs, 'mis' for general for-sale). Leave blank to scrape the whole category. Full list of codes in the README.

## `searchQuery` (type: `string`):

Free-text search run inside the chosen category (e.g. 'macbook pro', 'studio apartment', 'remote python'). Leave empty to browse the latest postings in the category. Supports Craigslist's own search operators.

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

Direct Craigslist search-result or post URLs. Overrides 'city', 'category', 'searchQuery' when set. Useful for re-running an exact saved-search URL. Each URL must be a Craigslist URL (host ends in '.craigslist.org').

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

Maximum number of listings to return per city. Craigslist paginates in 120-item pages; the actor pages until this limit or the search runs out. Hard ceiling 3000 per city (Craigslist's own browseable depth).

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

When true, opens each individual listing for full description, complete image gallery, post attributes, and reply URL — charged at the 'listing-detailed' rate ($0.008). When false, returns only the cheaper search-result card data (title, price, location, posted date, primary image, URL) charged at 'listing-scraped' ($0.005). Default false.

## `extractContacts` (type: `boolean`):

When true, extracts emails and phone numbers that appear in the public post body or visible reply URL. Requires includeDetails=true. Does NOT bypass Craigslist's anonymized reply form or log in. Only public, in-body data. Default false.

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

Minimum listing price filter, in the local currency of each city's marketplace (USD for US cities, GBP for London, etc.). Applies to categories that have a price column (for-sale, housing, services). Leave blank for no minimum.

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

Maximum listing price filter. Same currency rule as minPrice. Default 0 means no maximum. Use to skip out-of-budget cars or rentals.

## `hasPic` (type: `boolean`):

When true, only returns listings that include at least one image. Useful for resellers and real-estate filters. Default false.

## `ownerOnly` (type: `boolean`):

When true, only returns listings posted by owners — excludes dealer/agency/recruiter posts. Applies to for-sale (cars+trucks especially), housing, and jobs categories. Default false.

## `maxAgeDays` (type: `integer`):

Skip listings older than this many days. Craigslist sorts newest-first so the crawler stops paginating once a page contains only older posts. Default 0 means no age filter.

## `dedupAcrossCities` (type: `boolean`):

When true (default), keeps a per-run SHA-256 fingerprint of (normalised title + price + first image hostname) and drops any second occurrence — useful when scraping multiple metros where dealers post the same listing in several cities. Set false to keep every raw row.

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

Apify proxy settings. Residential proxies are strongly recommended at any non-trivial scale because Craigslist rate-limits datacenter IPs aggressively. Leave default for residential + country-auto.

## Actor input object example

```json
{
  "city": "sfbay",
  "cities": [],
  "category": "forsale",
  "subcategory": "cta",
  "searchQuery": "macbook pro",
  "startUrls": [],
  "maxResults": 50,
  "includeDetails": false,
  "extractContacts": false,
  "minPrice": 0,
  "maxPrice": 0,
  "hasPic": false,
  "ownerOnly": false,
  "maxAgeDays": 0,
  "dedupAcrossCities": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped Craigslist listings. Download as JSON, CSV, Excel, HTML, or RSS.

## `runSummary` (type: `string`):

End-of-run counts and warnings (cities scraped, total listings, charged listings, dedup hits, errors).

# 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 = {
    "city": "newyork",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/craigslist-all-in-one-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 = {
    "city": "newyork",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/craigslist-all-in-one-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 '{
  "city": "newyork",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/craigslist-all-in-one-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Craigslist Scraper - (Jobs & Listings etc.)",
        "description": "Scrape Craigslist classifieds across 700+ cities and all 8 categories (jobs, housing, for-sale, services, gigs, community, resumes, events). Typed outputs, multi-city fanout, repost dedup, optional contact extraction. MCP-ready. Pay-per-event.",
        "version": "0.3",
        "x-build-id": "aDpKH0Ex4XupkgE4h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~craigslist-all-in-one-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-craigslist-all-in-one-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/khadinakbar~craigslist-all-in-one-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-craigslist-all-in-one-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/khadinakbar~craigslist-all-in-one-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-craigslist-all-in-one-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": {
                    "city": {
                        "title": "City (subdomain)",
                        "type": "string",
                        "description": "Craigslist city subdomain to scrape (e.g. 'newyork', 'sfbay', 'losangeles', 'london'). Find the value in any Craigslist URL: the part before '.craigslist.org'. Use the preset 'topUSMetros' to fan out across the top 25 US metros, or 'topGlobalMetros' for the top 50 worldwide. Ignored when 'cities' or 'startUrls' is set."
                    },
                    "cities": {
                        "title": "Cities (multiple)",
                        "type": "array",
                        "description": "List of Craigslist city subdomains to scrape in one run (e.g. ['newyork','sfbay','losangeles']). Each subdomain produces an independent search. Leave empty to use the single 'city' field. NOT free-text city names — use the subdomain values.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "forsale",
                            "jobs",
                            "housing",
                            "services",
                            "gigs",
                            "community",
                            "resumes",
                            "events",
                            "all"
                        ],
                        "type": "string",
                        "description": "Top-level Craigslist category. 'forsale' covers all goods (cars+trucks, electronics, furniture, etc.); pick a 'subcategory' below for narrower results. Defaults to 'forsale'. Use 'all' to scrape every category (expensive — leaves volume control to 'maxResults').",
                        "default": "forsale"
                    },
                    "subcategory": {
                        "title": "Subcategory",
                        "type": "string",
                        "description": "Craigslist subcategory code that narrows the category (e.g. 'cta' for cars+trucks-all, 'apa' for apartments/housing, 'sof' for software jobs, 'mis' for general for-sale). Leave blank to scrape the whole category. Full list of codes in the README.",
                        "default": ""
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search run inside the chosen category (e.g. 'macbook pro', 'studio apartment', 'remote python'). Leave empty to browse the latest postings in the category. Supports Craigslist's own search operators.",
                        "default": ""
                    },
                    "startUrls": {
                        "title": "Start URLs (advanced)",
                        "type": "array",
                        "description": "Direct Craigslist search-result or post URLs. Overrides 'city', 'category', 'searchQuery' when set. Useful for re-running an exact saved-search URL. Each URL must be a Craigslist URL (host ends in '.craigslist.org').",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max results per city",
                        "minimum": 1,
                        "maximum": 3000,
                        "type": "integer",
                        "description": "Maximum number of listings to return per city. Craigslist paginates in 120-item pages; the actor pages until this limit or the search runs out. Hard ceiling 3000 per city (Craigslist's own browseable depth).",
                        "default": 50
                    },
                    "includeDetails": {
                        "title": "Fetch full post details",
                        "type": "boolean",
                        "description": "When true, opens each individual listing for full description, complete image gallery, post attributes, and reply URL — charged at the 'listing-detailed' rate ($0.008). When false, returns only the cheaper search-result card data (title, price, location, posted date, primary image, URL) charged at 'listing-scraped' ($0.005). Default false.",
                        "default": false
                    },
                    "extractContacts": {
                        "title": "Extract public contact info",
                        "type": "boolean",
                        "description": "When true, extracts emails and phone numbers that appear in the public post body or visible reply URL. Requires includeDetails=true. Does NOT bypass Craigslist's anonymized reply form or log in. Only public, in-body data. Default false.",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Minimum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum listing price filter, in the local currency of each city's marketplace (USD for US cities, GBP for London, etc.). Applies to categories that have a price column (for-sale, housing, services). Leave blank for no minimum.",
                        "default": 0
                    },
                    "maxPrice": {
                        "title": "Maximum price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum listing price filter. Same currency rule as minPrice. Default 0 means no maximum. Use to skip out-of-budget cars or rentals.",
                        "default": 0
                    },
                    "hasPic": {
                        "title": "Only listings with images",
                        "type": "boolean",
                        "description": "When true, only returns listings that include at least one image. Useful for resellers and real-estate filters. Default false.",
                        "default": false
                    },
                    "ownerOnly": {
                        "title": "Owner posts only (skip dealers)",
                        "type": "boolean",
                        "description": "When true, only returns listings posted by owners — excludes dealer/agency/recruiter posts. Applies to for-sale (cars+trucks especially), housing, and jobs categories. Default false.",
                        "default": false
                    },
                    "maxAgeDays": {
                        "title": "Max age (days)",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Skip listings older than this many days. Craigslist sorts newest-first so the crawler stops paginating once a page contains only older posts. Default 0 means no age filter.",
                        "default": 0
                    },
                    "dedupAcrossCities": {
                        "title": "Deduplicate reposts across cities",
                        "type": "boolean",
                        "description": "When true (default), keeps a per-run SHA-256 fingerprint of (normalised title + price + first image hostname) and drops any second occurrence — useful when scraping multiple metros where dealers post the same listing in several cities. Set false to keep every raw row.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Residential proxies are strongly recommended at any non-trivial scale because Craigslist rate-limits datacenter IPs aggressively. Leave default for residential + country-auto.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
