# Craigslist Scraper: Every Listing, Past the 360 Cap (`alexmorain/craigslist-scraper`) Actor

Scrape every Craigslist listing past the 360-per-search cap: 2,216 listings on a search the site stops at 360. One area, a state or all 707 sites, price, coordinates, photos, full ad text, no duplicates, new-listings monitoring.

- **URL**: https://apify.com/alexmorain/craigslist-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Lead generation, E-commerce, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 listings

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What does Craigslist Scraper do?

Craigslist Scraper exports **every listing of a [Craigslist](https://www.craigslist.org) search**, not just the first 360 that the site shows. Give it a keyword and a list of areas, or paste search URLs, and get one row per listing: title, price, currency, location with coordinates, photos, posting date, category and, if you ask for it, the full ad text with its attributes.

It works as a **Craigslist API**: plain HTTP requests to the JSON service the Craigslist search page itself calls. No browser, no login, no residential proxy.

#### Craigslist stops at 360 results per search

Whatever the search, Craigslist returns at most **360 listings** and has no page two. The page can say "2,205 results" and still only hand you 360 of them. A scraper that reads one search page per area silently loses the rest. This actor notices that a search hit the limit and cuts it into smaller searches (by price, then category, then sub-area, then date order) until nothing is left out. It removes the duplicates and tells you in the log how many listings were announced and how many it got.

Measured on 31 October 2026, on the Apify platform:

| Search | Announced by Craigslist | One search request (what the site shows) | Craigslist Scraper | Requests | Run time |
|---|---|---|---|---|---|
| SF Bay Area, musical instruments, "guitar" | 2,205 | 360 | **2,216** | 30 | 8 s |
| New York, all for sale, "iphone" | 1,260 | 360 | **1,265** | 113 | 7 s |
| Washington state (10 areas), musical instruments, "guitar" | n/a | 360 per area | **1,506**, no duplicates | 30 | 7 s |

The announced figure moves while a search runs, because the index is live, so the number returned can be a few above it. The 2,216 listings of the first row all have a distinct `postingUuid`.

### Why use Craigslist Scraper?

- **Resellers and sourcing.** Watch a category in dozens of cities for underpriced items, with price, photos and coordinates. Run it in **New listings only** mode on a schedule and pay only for what is new.
- **Market and price research.** Count listings and read asking prices by city, model or category. A search is no longer capped at the 360 most relevant ads.
- **Real estate, jobs and services leads.** Every Craigslist section works: `apa` apartments, `jjj` jobs, `bbb` services, `cta` cars, and the rest.
- **One search, any number of areas.** Pick a site (`sfbay`), a state (`US-CA`), a country (`FR`) or `all` for the 707 Craigslist sites. The actor skips the neighbouring areas' listings that Craigslist adds to thin areas, so each listing comes once.
- **Pipelines.** Rows go to the dataset in JSON, CSV or Excel, to Google Sheets, Slack, Zapier, Make or n8n, and a webhook tells you when a run ends. Apify adds scheduling, an API for every run and proxy rotation.

### What data can Craigslist Scraper extract?

| Field | Example | Description |
|---|---|---|
| `postingUuid` | `cmmqEaHXgWfCQzJPZo99k6` | Stable id of the listing. Use it to deduplicate across runs |
| `title` | `2 x 12 guitar stereo cabinet` | Title |
| `price`, `priceText`, `currency` | `500`, `$500`, `USD` | Asking price as a number, as shown, and the currency of the area. `null` when the seller gave no price |
| `url` | `https://www.craigslist.org/view/d/...` | Link to the listing |
| `area`, `areaName`, `subArea` | `sfbay`, `SF bay area`, `scz` | Craigslist site and sub-area |
| `category`, `categoryAbbr`, `categoryId` | `musical instruments - by owner`, `msg`, `98` | Category |
| `latitude`, `longitude`, `locationText` | `37.0313`, `-122.1198`, `santa cruz` | Where the seller placed the listing |
| `postedAt` | `2026-10-31T21:58:20Z` | When the listing was posted or last renewed, ISO 8601 UTC |
| `images`, `imageCount` | `["https://images.craigslist.org/..._600x450.jpg"]`, `13` | Photo URLs |
| `scrapedAt` | `2026-10-31T22:50:02Z` | When the row was collected |

With **Add the full ad (details)**, each row also has:

| Field | Example | Description |
|---|---|---|
| `postingId` | `7979888991` | Numeric posting id |
| `description`, `descriptionHtml` | `Solidly built by me...` | The complete ad text, plain and as Craigslist wrote it |
| `attributes` | `[{"key": "sale_manufacturer", "label": "make / manufacturer", "value": "Santos Guitar"}]` | Make, model, condition, size and other fields the seller filled in |
| `updatedAt` | `2026-10-31T21:53:20Z` | Last edit |
| `repostOf` | `7918991044` | Id of the earlier ad this one reposts, `null` for an original |
| `hasContactInfo` | `true` | Whether the ad carries contact information |
| `detailsFetched` | `true` | `false` on a row whose page was gone or unreachable |

Craigslist does not hand out sellers' phone numbers or e-mail addresses in the data this actor reads: `hasContactInfo` only says whether the ad has them. To contact a seller, use the `url`.

### How to scrape Craigslist

1. Click **Try for free**.
2. Type a **Keyword** (for example `stratocaster`) and a **Category** (`msa` is musical instruments, `sss` is everything for sale). Or paste Craigslist search URLs into **Craigslist search URLs**: the keyword, category, sub-area, price range and filters are read from the URL.
3. List the **Areas**: `sfbay`, `newyork`, `US-CA`, `FR` or `all`.
4. Set **Max listings**. It is also your cost cap.
5. Press **Start**, then download the dataset as JSON, CSV or Excel.

For daily or hourly watching, tick **New listings only** and add a schedule.

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

The actor is billed per result: a small fee per run, plus one charge per listing. A listing read with **details** costs more than a plain one. Prices fall with your Apify plan, from **$1.00 per 1,000 listings** on the free plan to **$0.50 per 1,000 at the Gold plan**, and $1.50 to $0.75 per 1,000 with details. The run start fee is $0.002.

Examples at the free-plan price: the 2,216 "guitar" listings of the SF Bay Area cost about $2.22 plus the start fee. 500 listings with the full ad cost $0.75. In **New listings only** mode, a listing delivered once is never charged again.

The platform cost of a run is small: the 2,216-listing run used $0.0115 of Apify usage, and 500 listings with details used $0.0032. **Max listings** and the per-run spending limit of your Apify account stop a run at the cap you set.

### Input

See the **Input** tab for every option. The ones worth knowing:

| Field | What it does |
|---|---|
| `searchUrls` | Craigslist search pages, one per line. Single listing pages are not accepted |
| `query`, `category` | Keyword and three-letter category. With `areas`, one search per area |
| `areas` | A site name (`sfbay`), a country (`US`, `FR`; `CA` is Canada), a US state or Canadian province (`US-CA`, `CA-ON`) or `all`. An unknown name stops the run before any request |
| `minPrice`, `maxPrice` | Price range in the local currency. Listings with no price are left out when set |
| `postedWithin` | Only the last N days. Reads newest first and stops at the window, so a short window is a handful of requests |
| `maxItems` | Total listings, all searches together. `0` is unlimited, except for a whole-category search without keyword on several areas, which is capped at 10,000 |
| `includeDetails` | Adds the full ad. One extra request per listing |
| `includeUnpriced` | Also returns listings with no price (a second pass, on by default) |
| `newOnly`, `registryKey` | Returns only listings not delivered by a previous run of the same search |
| `webhookUrl` | JSON summary posted when the run ends |

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. A listing without details:

```json
{
  "postingUuid": "mPpt5joUYA9Z7YdXYRmPKS",
  "postingId": null,
  "title": "Moog Theremini Theremin Synthesizer",
  "price": 290,
  "priceText": "$290",
  "currency": "USD",
  "url": "https://www.craigslist.org/view/d/oakland-moog-theremini-theremin/mPpt5joUYA9Z7YdXYRmPKS",
  "area": "sfbay",
  "areaName": "SF bay area",
  "subArea": "eby",
  "category": "musical instruments - by owner",
  "categoryAbbr": "msg",
  "categoryId": 98,
  "latitude": 37.7806,
  "longitude": -122.2166,
  "locationText": "oakland east",
  "postedAt": "2026-10-31T19:38:35Z",
  "updatedAt": null,
  "images": ["https://images.craigslist.org/00O0O_gX21lLLB4QR_0CI0nq_600x450.jpg"],
  "imageCount": 1,
  "repostOf": null,
  "hasContactInfo": null,
  "description": null,
  "descriptionHtml": null,
  "attributes": null,
  "detailsFetched": false,
  "scrapedAt": "2026-10-31T22:50:02Z"
}
```

The same listing with details adds `postingId`, `description`, `descriptionHtml`, `attributes`, `updatedAt`, `repostOf` and `hasContactInfo`, and sets `detailsFetched` to `true`.

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/craigslist-scraper").call(run_input={
    "query": "stratocaster",
    "category": "msa",
    "areas": ["US-CA", "US-WA"],
    "maxPrice": 1500,
    "maxItems": 2000,
})
for listing in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(listing["price"], listing["title"], listing["url"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('alexmorain/craigslist-scraper').call({
    searchUrls: ['https://sfbay.craigslist.org/search/msa?query=guitar'],
    includeDetails: true,
    maxItems: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length);
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~craigslist-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"query": "theremin", "category": "sss", "areas": ["all"], "maxItems": 100}'
```

### Tips

- **Bound a search without keyword.** A whole-category search of a big area holds hundreds of thousands of listings. Add a keyword or a narrower category, or set `maxItems`.
- **Use `postedWithin` for monitoring.** Reading the last day of a search costs the same few requests however large the search is.
- **A narrow category reads faster.** `msa` is one request when it has fewer than 360 results, `sss` can take dozens.
- **Read the log.** Each search prints one line: `sfbay msa 'guitar': announced 2205, retrieved 2216, 35 without price of ~33 expected, 30 requests.`

#### Monitoring with New listings only

The first run reads everything and then records that the read was complete. Later runs read only what was posted since, minus a two-day margin, and return only listings you have not been given. A run that stops early (`maxItems` reached, spending limit, a search that failed or a cell above 720 listings that the log reports) does not record a complete read, so the next run reads everything again. Listings already delivered are never charged twice.

A few listings without a price missing in a dense cell (the log says `a few listings without a price may be missing`) do not count as an incomplete read: the read is still recorded as complete. If you need every unpriced listing of a very dense search, split it into narrower searches.

### FAQ

#### How do I get more than 360 Craigslist results?

You split the search until each piece is under 360, then merge. Craigslist Scraper does it for you: it cuts by price range, then by category, then by sub-area, then by newest and oldest order, and reads the pieces in parallel. If a piece still holds more than 720 listings it says so in the log and the run status instead of hiding it.

#### Does it return listings without a price?

Yes, by default. Craigslist price filters drop them, so on searches that need splitting the actor runs a second pass for them. That pass is thorough on keyword searches. On very dense searches a few listings without a price can be missing, and the log names the cells where that may happen. Turn the pass off with `includeUnpriced` if you want priced listings only.

#### Why are some areas empty or why do I see fewer listings than Craigslist shows?

When an area has almost nothing for a keyword, Craigslist fills its page with listings from neighbouring areas (a search for "stratocaster" in Erie, PA announced 1 result and returned 60 listings from Cleveland, Pittsburgh and Buffalo). The actor keeps only the listings of the area you asked for. If you want the neighbours, paste a URL with `searchNearby=1`: they are then kept and deduplicated.

#### Can it get sellers' phone numbers or e-mails?

No. Craigslist keeps them behind its reply form. `hasContactInfo` tells you whether the ad has any.

#### Is the `postedAt` date the original posting date?

It is the date Craigslist shows, which moves forward when a seller renews or reposts. With details, `repostOf` gives the id of the earlier ad.

#### How long does a listing stay online?

Craigslist removes listings after a few weeks. A `url` that returns 404 means the listing is gone.

#### Is it legal to scrape Craigslist?

The actor reads public search results and listing pages that anyone can open without an account. Craigslist's terms of use restrict automated access to its site, so check them against your use. Our Actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

#### What if Craigslist changes?

The actor reads an internal Craigslist service, which can change without notice. If a run starts failing or returning less, open the Issues tab: report it there with the search you ran.

#### Support

Questions, a field you miss, a search that comes back short: use the **Issues** tab of this Actor. The **API** tab has the endpoints to start and read runs from your own code.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Craigslist Scraper page](https://alexis.morain.fr/en/scrapers/craigslist-scraper/) of my site. The [Classifieds and real estate family page](https://alexis.morain.fr/en/scrapers/families/classifieds-real-estate/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

## `searchUrls` (type: `array`):

Search pages copied from your browser, one per line, such as <code>https://sfbay.craigslist.org/search/msa?query=guitar</code> or <code>https://newyork.craigslist.org/search/mnh/sss?min_price=100</code>. Keyword, category, sub-area, price range and the <code>purveyor</code>, <code>hasPic</code>, <code>postedToday</code>, <code>condition</code> and <code>searchNearby</code> filters are read from the URL. Single listing pages are not supported. Can be combined with the keyword and areas below.

## `query` (type: `string`):

What to search for, such as <code>stratocaster</code> or <code>iphone 15</code>. Leave empty to list a whole category (then set <b>Max listings</b>: a big area holds hundreds of thousands).

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

Three-letter Craigslist category in the URL after <code>/search/</code>. <code>sss</code> = all for sale, <code>msa</code> = musical instruments, <code>ela</code> = electronics, <code>cta</code> = cars and trucks, <code>apa</code> = apartments, <code>jjj</code> = all jobs, <code>bbb</code> = all services. Empty = <code>sss</code> (all for sale).

## `areas` (type: `array`):

One entry per line. Accepts a Craigslist site name (<code>sfbay</code>, <code>newyork</code>, <code>paris</code>), a country code (<code>US</code>, <code>FR</code>, <code>GB</code>; <code>CA</code> means Canada), a US state or Canadian province (<code>US-CA</code>, <code>US-NY</code>, <code>CA-ON</code>), or <code>all</code> for every one of the 707 sites. An unknown name stops the run before any request. Empty with a keyword = <code>sfbay</code>.

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

Only listings priced at or above this amount, in the local currency. Listings without a price are left out when a price limit is set.

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

Only listings priced at or below this amount.

## `postedWithin` (type: `integer`):

Only listings posted in the last N days. Reads newest first and stops at the window, so a short window is a handful of requests whatever the size of the search.

## `maxItems` (type: `integer`):

Stops after this many listings, all searches together. Each listing is one charged result, so this is also your cost cap. <b>0 = no limit</b>, except for a keyword-less whole-category search on several areas, which is capped at 10,000.

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

Opens every listing to add the complete text, the attributes (brand, model, condition...), the real posting id, the last update time, the id of the ad it reposts and whether it carries contact info. One extra request per listing, charged at the higher <i>listing with details</i> price. Listings whose page is gone are delivered without details and charged the plain price.

## `includeUnpriced` (type: `boolean`):

Craigslist price filters drop listings with no price (1 to 6 % of a search), so the actor runs a second pass for them on searches that need splitting. Turn it off to save requests when you only want priced listings.

## `newOnly` (type: `boolean`):

Remembers which listings it already delivered for this exact search and returns only the new ones on the next run. Listings already delivered are not charged again. Schedule it hourly or daily.

## `registryKey` (type: `string`):

Name your monitoring memory to keep several independent watches on the same search, or to change the areas without losing history. Empty = one memory per distinct search.

## `webhookUrl` (type: `string`):

Receives a JSON summary (status, listings, run id, dataset id) when the run ends. Slack, Discord, Zapier and Make URLs work. Never logged.

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

Apify datacenter proxy is enough: Craigslist answered 3,000 requests in a row on one datacenter IP. The actor rotates the IP on a repeated refusal.

## Actor input object example

```json
{
  "query": "guitar",
  "category": "msa",
  "areas": [
    "sfbay"
  ],
  "maxItems": 50,
  "includeDetails": false,
  "includeUnpriced": true,
  "newOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

One row per listing

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

Every listing with all fields

# 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 = {
    "query": "guitar",
    "category": "msa",
    "areas": [
        "sfbay"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/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 = {
    "query": "guitar",
    "category": "msa",
    "areas": ["sfbay"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/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 '{
  "query": "guitar",
  "category": "msa",
  "areas": [
    "sfbay"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call alexmorain/craigslist-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,alexmorain/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/wO3oSg6iONWhfMSnf/builds/hpXX3FKlJBFIFd84Y/openapi.json
