# Facebook Marketplace Scraper: listings inside your area (`alexmorain/facebook-marketplace-scraper`) Actor

Scrape Facebook Marketplace listings that are really inside the area you ask for (distance computed, not Facebook's radius), past the ~2,400 per search limit, with a returned / duplicates / outside-the-zone / delivered count. Listing pages by URL, new-listing and price-drop monitoring.

- **URL**: https://apify.com/alexmorain/facebook-marketplace-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** E-commerce, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 0 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 Facebook Marketplace Scraper do?

Facebook Marketplace Scraper returns the listings of [Facebook Marketplace](https://www.facebook.com/marketplace/) that are **really inside the area you ask for**: a search term, a city or a latitude and longitude, and a radius in kilometers. It works as a Facebook Marketplace API alternative for people who need rows, not a browser tab: no Facebook account, no login, no browser, plain HTTP, results in a dataset you can export as JSON, CSV, Excel or XML.

Two things make a plain Marketplace export wrong, and this actor fixes both.

First, **Facebook cuts every search at about 2,400 listings** and never tells you. Ask for "iphone" around New York and you get roughly 2,400 rows, whatever the real stock is. This actor splits the price range in two, again and again, until every slice fits under the cut. On the same New York search it returned 11,068 listings in the zone, against 1,733 for a single search.

Second, **Facebook's radius does not filter anything**. Once the local stock runs out, Facebook fills the search with listings from cities far away. In our tests only 43% to 45% of the listings returned by a 65 km search around New York were inside 65 km. This actor computes the distance of every listing from the center you gave it, keeps the ones inside the radius and **charges you only for those**.

Every run writes a SUMMARY record with the proof: returned by Facebook, duplicates, outside the zone and delivered.

#### The 2,400 cap and the radius, measured

Tests on 7 November 2026, searches around New York with a 65 km radius, one plain Facebook search each:

| Search | Returned by Facebook | Inside 65 km | Share inside |
|---|---|---|---|
| couch | 2,401 | 1,024 | 43% |
| iphone | 2,369 | 1,063 | 45% |

More than half of what Facebook calls "within 65 km" is not. A seller in Philadelphia, Baltimore or Boston ends up in a New York export, and a price study built on it is wrong.

Runs on the Apify platform, 8 November 2026, residential US proxy, 512 MB:

| Search | Mode | Returned by Facebook | Delivered, inside the zone | Run time | Run |
|---|---|---|---|---|---|
| iphone, New York 65 km | Full coverage off, strict zone off | 2,081 | 2,059 (1,733 inside the zone) | 85 s | `SXdpWd6HDqX4oD2Th` |
| iphone, New York 65 km | Full coverage on, strict zone on | 30,892 | **11,068** | 11 min 40 s | `h5EaDPj24PwXy6L57` |
| couch, Los Angeles 40 km | Full coverage on, strict zone on | 50,699 | **12,900** | 19 min | `ejbtjwtDOlORtVCdF` |
| bike, Paris 30 km | Full coverage on, strict zone on | 5,023 | 631 | 4 min 16 s | `dNdlBfwMpZaYKsGSM` |

The second row is the point. To find 11,068 listings inside the zone the actor had to read 30,892 rows from Facebook: 14,773 of them were duplicates (the same listing appears in several price slices), 5,047 were outside the zone, and the rest are the 11,068 you receive and pay for. The SUMMARY record of that run says so:

```json
{
  "listingsReturned": 11068,
  "inputs": [{
    "input": "iphone @ New York, NY",
    "status": "ok",
    "radiusKm": 65.0,
    "returnedByFacebook": 30892,
    "uniqueListings": 16119,
    "duplicatesSkipped": 14773,
    "outOfZone": 5047,
    "unlocated": 4,
    "pagesRead": 1273,
    "fluxes": 26
  }]
}
```

The numbers add up: 16,119 unique listings, minus 5,047 outside the zone, minus 4 that Facebook gave no city for, leaves 11,068.

### Why use Facebook Marketplace Scraper?

A listing outside your area is noise. If you price used iPhones in New York or watch bikes in Paris, you want the listings a buyer there would see, all of them, not the first 2,400 of a sort order.

- Resellers and flippers: every listing of a category in a city, with price, age of the listing and condition, to spot under-priced items before someone else does.
- Price researchers and analysts: a clean sample for a market study, a price index or a model, with distance and place on every row.
- Dealers and marketplaces: a daily feed of new listings, or of listings whose price dropped, delivered by webhook.

What you get on top of a plain search export:

- **Strict zone**: the distance is computed for every listing, and only the ones inside your radius are returned and charged. Turn it off to receive everything Facebook returns, with `distanceKm` and `inZone` on every row.
- **Full coverage** past the 2,400 cap, with duplicates removed before they are charged.
- Exact coordinates and the distance from the exact point when you read the listing page.
- Watch mode: only new listings, or new listings plus price changes with the previous price, and a webhook when a run returns something.
- Listing pages by URL or id: description, condition, attributes, all photos, seller since date.
- Residential proxies included in the price. There is nothing to configure and no proxy bill of your own.
- Apify platform features: scheduling, API access, integrations with Make, Zapier, n8n and Google Sheets, run history and monitoring.

### What data can Facebook Marketplace Scraper extract?

A search row has about 30 fields. With **Listing pages** on, or when you read a listing by URL, the row also gets the page fields (description, condition, attributes, all photos, seller since date, category name). The full list, from the dataset schema:

| Field | Type | Description |
|---|---|---|
| `id` | string | Marketplace listing id |
| `url` | string | Listing page on Facebook |
| `title` | string | Listing title |
| `price` | number | Price in the zone's currency. 0 means free |
| `currency` | string | Currency code, from the country of the zone |
| `formattedPrice` | string | Price as shown on Facebook |
| `strikethroughPrice` | number | Previous price when the seller lowered it |
| `isFree` | boolean | True when the price is 0 |
| `photoUrl` | string | Main photo. Facebook photo links expire after a while: download them if you keep them |
| `createdAt` | string | When the listing was created (ISO 8601, UTC) |
| `city` | string | City of the listing |
| `state` | string | State or region code as Facebook gives it |
| `cityPageId` | string | Facebook page id of the city |
| `latitude` | number | Latitude: centroid of the city, or the exact point with the listing page |
| `longitude` | number | Longitude, same rule |
| `locationPrecision` | string | `city` for a city centroid, `exact` for the coordinates of the listing page |
| `distanceKm` | number | Distance from the center of your zone, in km |
| `inZone` | boolean | Within the radius. Always true with strict zone on. Null when no city is known |
| `isLive` | boolean | Listing is live |
| `isSold` | boolean | Listing is marked sold |
| `isPending` | boolean | Sale pending |
| `deliveryTypes` | array | How the listing can be received: IN_PERSON, SHIPPING_ONSITE, PUBLIC_MEETUP, DOOR_PICKUP, DOOR_DROPOFF |
| `sellerName` | string | Seller name as shown on the listing |
| `sellerId` | string | Seller id (opaque `pfbid`) |
| `categoryId` | string | Marketplace category id |
| `hasVideo` | boolean | Listing has a video |
| `searchQuery` | string | The search term that found it |
| `searchLocation` | string | The place that was searched |
| `radiusKm` | number | Radius of the zone searched |
| `scrapedAt` | string | When the row was read (ISO 8601, UTC) |
| `previousPrice` | number | Monitoring: price returned by the previous run. Null for a new listing |
| `priceChange` | string | Monitoring: `new`, `down` or `up` |
| `detailsStatus` | string | With listing pages on: `ok`, or `failed`, `gone`, `timeout`. A failed read is charged as a plain listing |
| `description` | string | Seller's description (listing page) |
| `condition` | string | `new`, `used_like_new`, `used_good` or `used_fair` (listing page) |
| `attributes` | object | Other attributes shown on the listing page |
| `photos` | array | All photo URLs (listing page) |
| `sellerJoinedAt` | string | When the seller joined Facebook (listing page) |
| `categoryName` | string | Marketplace category name (listing page) |

Fields that a run did not read are absent from the row (the monitoring fields appear only when monitoring is on, the listing page fields only with listing pages on). Fields that Facebook does not give for a listing come back as null. A listing page can also come back with an empty description when the seller wrote none.

### How to scrape Facebook Marketplace

1. Open the actor in Apify Console and go to the Input tab.
2. In Search queries, type what you would type in the Marketplace search box: `iphone`, `couch`, `bike`.
3. In Places, type a city: `New York, NY`, `Austin, Texas`, `Paris` or `Lyon, France`. Each search term is run for each place.
4. Set the Radius in kilometers. The default is 40.
5. Set Max items. Use 100 for a first test. Empty means every listing of the zone, which is tens of thousands for a big city.
6. Click Start. The status message and the SUMMARY record show how many listings Facebook returned and how many were delivered.
7. Download the dataset from the Output tab as JSON, CSV or Excel, or read it through the API.

Already have a search on facebook.com? Set its filters, copy the URL and paste it into Marketplace search URLs. The center, the term and the filters are read.

### Ways to tell the actor what to read

You can mix inputs in the same run. Each one gets its own entry in the SUMMARY record and its own status.

#### Search terms and places

`searchQueries` and `locations` are combined: two terms and three places make six searches. The place is looked up in a built-in gazetteer of world cities. When a name is shared, the most populated place wins, so add the state or the country: `Springfield, MO` rather than `Springfield`. A place that cannot be found ends as `not-found` and the status message names it.

```json
{
  "searchQueries": ["iphone", "macbook"],
  "locations": ["New York, NY", "Boston, MA"],
  "radiusKm": 50,
  "maxItems": 5000
}
```

#### Exact center (latitude and longitude)

For a center no city name gives, such as a warehouse or a neighborhood, use `latitude` and `longitude` together, for example `34.0522` and `-118.2437`. They are added to the places.

#### Marketplace search URLs (startUrls)

A search page copied from your browser, for example `https://www.facebook.com/marketplace/austin/search?query=bike&maxPrice=200`. The center is read from the page. The `query`, `minPrice`, `maxPrice`, `daysSinceListed`, `sortBy`, `itemCondition` and `radius` of the URL are respected. A URL that is not a Marketplace search page with a query is skipped, with a warning in the log.

#### Listing URLs or ids (listingUrls)

`https://www.facebook.com/marketplace/item/1234567890/` or the bare id. Each one returns the full listing page row and is charged as a detailed listing. This is the mode for pipelines that already hold a list of ids.

#### Radius and strict zone

The radius is in kilometers, from 1 to 500. With Strict zone on (the default), a listing is delivered and charged only when it is inside the radius. The distance is computed from the city Facebook gives for the listing, using the coordinates of that city, or from the exact point when the listing page is read. Turn Strict zone off to receive everything Facebook returns: every row then carries `distanceKm` and `inZone`, so you can filter yourself.

#### Full coverage

On by default. The actor reads one search first. If Facebook stops it at the cap, the price range is split in two at the median price of what was read, and each half is read the same way, again and again, until each slice ends by itself. The slices are read in parallel and the duplicates between them are removed. With Full coverage off, you get one search: about 2,400 listings from Facebook, then the strict zone filter on top, and a note in the SUMMARY that says what was left out.

With Max items set, the actor reads the slices breadth first, so a limit of 300 spreads over the price range instead of filling the cheapest listings only.

#### Filters

| Field | What it does |
|---|---|
| `minPrice`, `maxPrice` | Price, in the currency of the zone (dollars, euros...). Both ends are included |
| `sortBy` | `relevance`, `newest`, `priceLowToHigh`, `priceHighToLow` |
| `itemCondition` | `new`, `used_like_new`, `used_good`, `used_fair` |
| `daysSinceListed` | Only listings created in the last N days, from 1 to 365 |

Each filter was checked on the rows Facebook returned: price bounds hold on both ends, sort orders hold, and each condition value returned only that condition (8 of 8 listing pages per value).

`daysSinceListed` is done by the actor, not by Facebook. Facebook's own date parameter returns no listing at all when you use it without an account, so the actor reads the search newest first, keeps the listings created inside your window and stops as soon as the results get older. It is also the cheapest way to watch a market, because the run ends after the first old page.

#### Listing pages (includeDetails)

Opens the page of each listing and adds the description, the condition, the attributes, all the photos, the date the seller joined Facebook, the category name and the **exact coordinates**. The distance is then computed from the exact point, not from the city. The page is a heavy download (about 1.2 MB), so the run is slower: 50 listing pages took 67 seconds (run `hNdONjbwIpzJ0lafQ`), 46 of them with a description. A listing that is gone or cannot be read is returned with the search fields and `detailsStatus` set to `gone`, `failed` or `timeout`, and charged as a plain listing.

With Strict zone on, a listing whose page puts it outside the radius is dropped and not charged. A listing for which Facebook gave no city is delivered only if its page gives an exact point inside the radius.

### Monitor new listings and price changes

Set Monitoring to get a feed instead of a full export.

- **New listings only** returns the listings that no earlier run with the same input returned.
- **New listings and price changes** also returns the listings whose price moved, with `previousPrice` and `priceChange` (`up` or `down`). Listings new to the watch get `priceChange` set to `new`.

The first run returns everything, since nothing has been seen yet. After that, unchanged listings are neither returned nor charged. The memory lives in a named key-value store in your account called `facebook-marketplace-monitor`, one record per search and per monitor name. Runs that share the same input and the same Monitor name share one memory. Change the name to start a second, separate watch on the same search. Entries are saved at the end of the run, and a run that dies before that simply sends the same listings again next time.

A test on `bike` in Austin, 300 listings, on 8 November 2026: the first run returned 300 and the second run returned 300 more that the first had not seen, and skipped 286 it had already delivered, in 24 and 31 seconds (runs `JG7BXz43Z6kGhIx89` and `RKLkycshHAsbllcK1`).

For a watch, set `sortBy` to `newest` and `daysSinceListed` to 1 or 2, so each run reads only the fresh end of the search.

#### Schedule it

In Apify Console, open Schedules, pick the actor, paste the input and set a cron expression. A run every hour with monitoring on gives you the listings of the last hour.

#### Webhook

Set Webhook URL to get a POST at the end of the run, only when the run returned at least one row. A watch that finds nothing new sends nothing. The body is JSON:

```json
{
  "actor": "facebook-marketplace-scraper",
  "runId": "...",
  "datasetId": "...",
  "monitorMode": "newOnly",
  "items": 21,
  "byEvent": { "listing": 21 },
  "text": "Facebook Marketplace Scraper: 21 listing(s) new or changed since the last run.",
  "inputs": [{ "input": "bike @ Austin, TX", "status": "ok", "listingsReturned": 21 }]
}
```

The body also carries a `content` field with the same text. `text` is what Slack incoming webhooks read and `content` is what Discord reads, so both work without a relay. Redirects are not followed, except 307 and 308. A webhook that fails is logged and does not fail the run. The webhook URL is stored as a secret input.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. Here is a real row from a run with Listing pages on (a `bike` search around Austin, 8 November 2026, run `hNdONjbwIpzJ0lafQ`). The seller name and id are replaced, and the photo links are shortened to one:

```json
{
  "id": "1645211487042746",
  "url": "https://www.facebook.com/marketplace/item/1645211487042746/",
  "title": "Bike",
  "price": 200,
  "currency": "USD",
  "formattedPrice": "$200",
  "strikethroughPrice": null,
  "isFree": false,
  "photoUrl": "https://scontent-den2-1.xx.fbcdn.net/v/t39.84726-6/887094230_1150088017554371_519268544994289305_n.jpg",
  "createdAt": "2026-11-06T03:14:23+00:00",
  "city": "Austin",
  "state": "TX",
  "cityPageId": "106224666074625",
  "latitude": 30.270080566406,
  "longitude": -97.750854492188,
  "locationPrecision": "exact",
  "distanceKm": 0.8,
  "inZone": true,
  "isLive": true,
  "isSold": false,
  "isPending": false,
  "deliveryTypes": ["IN_PERSON"],
  "sellerName": "Jane D.",
  "sellerId": "pfbid0xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
  "categoryId": "1658310421102081",
  "hasVideo": false,
  "searchQuery": "bike",
  "searchLocation": "Austin, TX",
  "radiusKm": 40,
  "scrapedAt": "2026-11-08T02:40:20+00:00",
  "description": "",
  "condition": "used_like_new",
  "attributes": { "Condition": "Used - like new" },
  "sellerJoinedAt": "2025-03-23T20:30:57+00:00",
  "categoryName": "Bicycles",
  "photos": [
    "https://scontent.fosu3-1.fna.fbcdn.net/v/t39.84726-6/887094230_1150088017554371_519268544994289305_n.jpg"
  ],
  "detailsStatus": "ok"
}
```

Without Listing pages, the row stops at `scrapedAt` and `locationPrecision` is `city`: the latitude and longitude are then the centroid of the listing's city, and `distanceKm` is measured from there.

In a monitored run, the row also has `previousPrice` (200, say) and `priceChange` (`down`).

### How much will it cost to scrape Facebook Marketplace?

The actor uses Apify's pay-per-event pricing. You pay for events, and the residential proxy that Facebook requires is included.

| Event | Charged when | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|---|
| Listing | A unique listing inside the zone is returned | $1.00 per 1,000 | $0.87 | $0.73 | $0.50 |
| Detailed listing | A listing is returned with its page data, or a listing is read by URL or id. Charged instead of Listing | $2.00 per 1,000 | $1.75 | $1.45 | $1.00 |
| Actor start | The run starts, per GB of memory (the default is 512 MB, one event minimum) | $0.002 | $0.002 | $0.002 | $0.002 |

The plan tier is the one of your Apify subscription, and the higher plans pay less. **Only listings inside the zone and not already returned are charged.** A listing seen twice in a run is charged once. A listing outside the radius is read by the actor but not charged. A listing skipped by the watch because it was already returned is not charged. A listing page that could not be read is charged as a plain listing.

Example: the New York run above, 11,068 listings inside 65 km, no listing pages (run `h5EaDPj24PwXy6L57`):

| Plan tier | Listings | Total with the start event |
|---|---|---|
| Free | 11,068 x $0.00100 = $11.07 | $11.07 |
| Bronze | 11,068 x $0.00087 = $9.63 | $9.63 |
| Silver | 11,068 x $0.00073 = $8.08 | $8.08 |
| Gold | 11,068 x $0.00050 = $5.53 | $5.54 |

Other examples at the Free rate: a test of 100 listings costs $0.10 plus the start, 1,000 listings with page data cost $2.00, a daily watch that sees 30 new listings costs about $0.03 a run.

To keep a test cheap, set Max items or the maximum charge per run in the run options. At the maximum charge the actor stops and keeps the rows it already read.

### Input

See the Input tab for every field with its description. The ones that need a word:

`searchQueries` and `locations` are combined, and `startUrls` and `listingUrls` come on top of them. `maxItems` is a total across all inputs, and empty or 0 means every listing of the zone. `monitorName` separates two watches on the same search. `proxyConfiguration` defaults to Apify's residential proxy and should stay there: Facebook refuses datacenter addresses.

A watch with a webhook:

```json
{"searchQueries": ["bike"], "locations": ["Austin, TX"], "radiusKm": 30, "sortBy": "newest", "daysSinceListed": 2, "monitorMode": "newAndPriceChanges", "webhookUrl": "https://hooks.slack.com/services/..."}
```

### Integrations: Python, JavaScript and cURL

These examples use the actor `alexmorain/facebook-marketplace-scraper`. Replace the token with your own.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("alexmorain/facebook-marketplace-scraper").call(run_input={
    "searchQueries": ["iphone"],
    "locations": ["New York, NY"],
    "radiusKm": 65,
    "minPrice": 100,
    "maxPrice": 900,
    "itemCondition": "used_good",
    "maxItems": 2000,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["title"], row["price"], row["city"], row["distanceKm"])

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")["value"]
for entry in summary["inputs"]:
    print(entry["input"], entry["returnedByFacebook"], entry["outOfZone"], entry["listingsReturned"])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });

const run = await client.actor('alexmorain/facebook-marketplace-scraper').call({
    searchQueries: ['bike'],
    latitude: 30.2672,
    longitude: -97.7431,
    radiusKm: 25,
    sortBy: 'newest',
    daysSinceListed: 7,
    maxItems: 500,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
const drops = items.filter((r) => r.priceChange === 'down');
console.log(items.length, 'listings,', drops.length, 'price drops');
```

#### cURL

Start a run and wait for the rows in one call:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/alexmorain~facebook-marketplace-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries": ["bike"], "locations": ["Austin, TX"], "radiusKm": 40, "maxItems": 50}'
```

A synchronous call times out after five minutes: use it for short runs. For a whole city, start the run with `POST /v2/acts/alexmorain~facebook-marketplace-scraper/runs` and read the dataset when it ends.

### Limits, written plainly

- **A residential proxy is required.** Facebook refuses datacenter IP addresses and Apify's default addresses. The actor uses Apify's residential proxy, which is included in the price. If you change the proxy to a datacenter group, the run will not read anything.
- **No Facebook account is used.** The actor reads what Facebook shows to a visitor who is not logged in. Anything that needs a login is out of reach: your own saved items, messages, listings visible only to friends.
- **The distance is measured from the city of the listing.** Facebook gives a city and a state for a listing, not a point. The actor locates that city in the GeoNames gazetteer and measures from its centroid. A listing in a large city can be a few kilometers from the centroid, so a listing near the edge of your radius can fall on either side. Turn on Listing pages to get the exact point and measure from it.
- **Towns with the same name.** When two towns share a name, the actor keeps the one in the state or region Facebook gives (in the United States and the United Kingdom directly, in France and Canada through a table of region codes, elsewhere from the region codes the run learns on towns with a single match). A town with the same name in the same state, outside the zone, cannot be told apart from the one inside it: the actor keeps the nearer one. Turn on Listing pages for the exact point when that matters.
- **Some listings cannot be placed.** Facebook gives no city for a few listings (4 out of 16,119 in the New York run). They are counted as `unlocated` in the SUMMARY and, with Strict zone on, delivered only if the listing page gives an exact point inside the radius. A city that is not in the gazetteer within the radius plus 150 km is treated as outside the zone, which is what `outOfZoneBeyondReach` counts.
- **Two price slices can stay at Facebook's cap.** When many listings share one exact price, splitting the price range cannot separate them. The actor stops splitting at 8 levels of depth or 80 searches per input, and the SUMMARY `note` says how many price ranges could not be cut further. In that case a few listings of the zone are missing, and the note tells you where.
- **Facebook's results are not stable.** Two identical searches rendered 2,701 and 2,081 rows in our tests, with 494 and 22 duplicates. The set of listings changes between runs because the listings change. Do not expect to recover the same rows twice.
- **Strict zone costs reads.** Finding the listings inside a zone means reading many that are not: the New York run read 30,892 rows to deliver 11,068. You pay only for the delivered rows, but the run lasts longer than the count suggests.
- **Delivery method is not offered as a filter.** Facebook has a switch that drops the local pickup restriction. Turned on, it returns items shipped from all over the country, which have no place in a zone. The default search already returns local pickup listings, and `deliveryTypes` on every row lets you filter further yourself.
- **Facebook can refuse requests.** The actor changes IP and retries. If Facebook refuses everywhere, the run ends FAILED with a message instead of a half empty dataset. One failing input does not stop the others.

### FAQ

#### How to scrape Facebook Marketplace?

Use the form in Apify Console: a search term, a city, a radius, and click Start. For code, call the actor from Python, JavaScript or cURL, as in the examples above. You do not need a Facebook account, a browser or your own proxy.

#### Is there a Facebook Marketplace API?

Not an open one. Meta does not offer a public API to read Marketplace listings. Its Commerce and Catalog APIs are for sellers who manage their own catalog. This actor is the other route: it reads the public pages and gives you the rows a visitor would see, in a dataset or through the Apify API, as JSON, CSV or Excel.

#### How to export Facebook Marketplace listings to CSV?

Run the actor, open the Output tab of the run and choose CSV, or Excel or JSON, in the export menu. Through the API, call `GET /v2/datasets/<datasetId>/items?format=csv`. You can pick the columns with the `fields` parameter, for example `fields=title,price,city,distanceKm,url`.

#### Facebook Marketplace radius not working: why?

Because Facebook's radius is a hint, not a filter. In our tests, a search around New York with a 65 km radius returned 2,401 listings for "couch", and only 1,024 of them (43%) were inside 65 km. Once the local stock runs out, Facebook fills the results with listings from other states. This actor measures the distance of every listing and keeps the ones inside your radius (Strict zone, on by default). Turn Strict zone off and every row still has `distanceKm` and `inZone`, so you can check Facebook's answer yourself.

#### How to get more than 2,400 results on Facebook Marketplace?

Facebook stops a search at about 100 pages, or 2,400 listings, whatever the real stock, and gives no total or warning. The only way past it is to cut the search in smaller ones and merge the results. That is what Full coverage does, by splitting the price range. A New York search for "iphone" gave 1,733 listings inside the zone from a single search and 11,068 with Full coverage (runs `SXdpWd6HDqX4oD2Th` and `h5EaDPj24PwXy6L57`). A search for "couch" around Los Angeles gave 12,900 (run `ejbtjwtDOlORtVCdF`).

#### Can I get Facebook Marketplace price alerts?

Yes. Set Monitoring to "New listings and price changes", sort by newest, and schedule the run every hour or every day. Each run returns only the listings that are new, or whose price moved, with `previousPrice` and `priceChange`. Add a Slack or Discord webhook URL to get a message when something comes up.

#### Can I search several cities?

Put several places in Places, and each search term is run for each of them. There is no country-wide mode: a Marketplace search is always around a center. For a big region, use a list of cities with a smaller radius each, or a radius up to 500 km. Each search term and place pair is its own search: a listing found by two of them comes out once for each, with its `searchQuery` and `searchLocation`, and is charged once for each. Within one pair, a listing is delivered and charged once.

#### Does it work outside the United States?

Yes. The places come from a gazetteer that covers 246 countries, and the currency is taken from the country of the zone. We checked it with a search for "vélo" around Paris (30 km, 631 listings inside the zone, run `dNdlBfwMpZaYKsGSM`). The residential proxy is picked in the country of the zone. Results vary with the country of the proxy, which is why it follows the zone.

#### Is it legal to scrape Facebook Marketplace?

This is not legal advice. The data this actor reads is what Facebook shows to a visitor who is not logged in: public listings, no account data and no private information. Whether collecting it is allowed depends on what you do with it, where you are and Facebook's terms of use, which limit automated access. Read them before building a product on the data, and follow the laws that apply to you. The rows can contain personal data, such as the name of a seller. In the European Union the GDPR applies to it, and other countries have their own rules. Keep only what you need, do not use seller names for unsolicited messages, and ask a lawyer if the use is commercial and at scale.

### Disclaimers and support

Our actors do not extract private user data such as email addresses, phone numbers or the location of users. They only extract what Facebook shows publicly on Marketplace listings. Your results can still contain personal data, such as the name of a seller. Personal data is protected by the GDPR in the European Union and by other regulations around the world. Do not scrape personal data unless you have a legitimate reason, and if you are unsure whether yours is legitimate, consult a lawyer. This actor is not affiliated with or endorsed by Meta or Facebook.

Geographic data from GeoNames (geonames.org), CC BY 4.0.

Something wrong or missing? Use the Issues tab of this actor. Send the run id and the input. The API tab has the endpoints and ready-made code to start the actor from your own tools.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Facebook Marketplace Scraper page](https://alexis.morain.fr/en/scrapers/facebook-marketplace-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

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

What to look for, as you would type it in the Marketplace search box: <code>iphone</code>, <code>couch</code>, <code>vélo</code>. Each query is run for each place below.

## `locations` (type: `array`):

City as <code>New York, NY</code>, <code>Austin, Texas</code>, <code>Paris</code> or <code>Lyon, France</code>. The most populated place of that name is used (add the state or country when a name is shared). Or use latitude and longitude below for an exact center.

## `latitude` (type: `number`):

Center of the zone, instead of a place. Give latitude and longitude together.

## `longitude` (type: `number`):

Center of the zone, instead of a place.

## `radiusKm` (type: `number`):

Radius of the zone, in kilometers, around the center. With <b>Strict zone</b> on, only listings placed within this distance are returned. Facebook's own radius filter does not filter anything, so the distance is computed from each listing's city.

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

Optional. Search pages copied from your browser, such as <code>https://www.facebook.com/marketplace/austin/search?query=bike\&maxPrice=200</code>. The center is read from the page; <code>query</code>, <code>minPrice</code>, <code>maxPrice</code>, <code>daysSinceListed</code>, <code>sortBy</code>, <code>itemCondition</code> and <code>radius</code> of the URL are respected.

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

Optional. Read single listings: <code>https://www.facebook.com/marketplace/item/1234567890/</code> or the bare id. Always returned with the full listing page (description, condition, exact location, all photos), charged as a detailed listing.

## `minPrice` (type: `number`):

In the currency of the zone (dollars, euros...). Applied by Facebook to every search.

## `maxPrice` (type: `number`):

In the currency of the zone. Empty = no maximum.

## `sortBy` (type: `string`):

Order of the results. <code>newest</code> is the most useful for monitoring.

## `daysSinceListed` (type: `integer`):

Only listings created in the last N days. Done by the actor on the creation date (Facebook's own date filter does not work anonymously), with the newest-first order so the search stops as soon as results get older.

## `itemCondition` (type: `string`):

Only listings in this condition. Empty = any.

## `strictZone` (type: `boolean`):

On: only listings really within the radius are returned (and charged). Facebook fills a search with listings from far away cities once the local stock runs out: on a New York search, 55% of what Facebook returns is outside 65 km. Off: everything Facebook returns is delivered, with <code>distanceKm</code> and <code>inZone</code> on each row.

## `fullCoverage` (type: `boolean`):

Facebook stops a search at about 100 pages (~2,400 listings) however many exist. On, the price range is split in two at the median, again and again, until every slice fits, so a big city returns tens of thousands of listings. Off, one search: you get Facebook's ~2,400 and a note.

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

Open each listing page for the description, condition, attributes, all photos, seller since date and exact coordinates (the distance is then computed from the exact point). Slower and charged as a detailed listing.

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

Stops after this many listings in total. Empty or 0 = every listing of the zone: tens of thousands for a big city, so set a limit or a maximum charge per run when you test.

## `monitorMode` (type: `string`):

<b>New listings only</b> returns only listings not returned by an earlier run with the same input (and monitor name). <b>New and price changes</b> also returns listings whose price moved, with <code>previousPrice</code> and <code>priceChange</code> (up / down). Unchanged listings are neither returned nor charged. The first run returns everything. State is kept in a store named <code>facebook-marketplace-monitor</code> in your account.

## `monitorName` (type: `string`):

Optional. Separates two monitors that use the same search.

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

Optional. A JSON summary is POSTed here when the run ends with at least one listing. Slack and Discord incoming webhooks work. Redirects are not followed (except 307 / 308).

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

Facebook blocks datacenter IPs: the default is Apify's <b>residential</b> proxy, in the country of the zone (results vary with the proxy country). Change it only if you know why.

## Actor input object example

```json
{
  "searchQueries": [
    "bike"
  ],
  "locations": [
    "Austin, TX"
  ],
  "radiusKm": 40,
  "sortBy": "relevance",
  "strictZone": true,
  "fullCoverage": true,
  "includeDetails": false,
  "maxItems": 20,
  "monitorMode": "off",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All listings in the default dataset.

## `summary` (type: `string`):

Status of each search or listing: listings returned by Facebook, duplicates, outside the zone, unlocated, delivered, the price slices read (pages, reason each one stopped), requests, refusals and IP rotations.

# 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": [
        "bike"
    ],
    "locations": [
        "Austin, TX"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/facebook-marketplace-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": ["bike"],
    "locations": ["Austin, TX"],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/facebook-marketplace-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": [
    "bike"
  ],
  "locations": [
    "Austin, TX"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call alexmorain/facebook-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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