# Facebook Marketplace Scraper (`socialdataapi/facebook-marketplace-scraper`) Actor

Facebook Marketplace Scraper — Extract Facebook Marketplace listings, including product names, prices, descriptions, images, locations, seller details, categories, and listing URLs. Useful for price comparison, product research, competitor analysis, and local market insights.

- **URL**: https://apify.com/socialdataapi/facebook-marketplace-scraper.md
- **Developed by:** [Social Data API](https://apify.com/socialdataapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.79 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### Facebook Marketplace Scraper — Prices, Photos and Seller Info

Facebook Marketplace Scraper turns a Facebook Marketplace search URL into structured listing data: title, price, photos, seller name, condition, description, and map location. **Every response is structured JSON** — ready to pass directly to an LLM, index into a vector store, or feed a resale price-tracking pipeline. No Facebook account or login is needed, since every request reads only what a logged-out visitor's own search page already shows. Start with one search URL, then add more to track every city or category you resell in.

***

### What data can I extract with Facebook Marketplace Scraper?

Using this Facebook Marketplace Scraper, you will be able to extract the following Facebook Marketplace listing data:

| 🏷️ Title | 💲 Price | 🖼️ Photo gallery | 🧰 Condition (deep mode) |
| --- | --- | --- | --- |
| 📝 Description (deep mode) | 🧩 Structured attributes (deep mode) | 📍 Location (city/state; coordinates in deep mode) | 🕒 Posting time (deep mode) |
| 🧑 Seller name and profile id | 🚚 Delivery options | 🗂️ Marketplace category ID | 🔗 Listing URL |
| 🔎 Search URL | 🚦 Sold / live / pending / hidden status | 🔖 Discount (strikethrough) price | 🎬 Video attachment (if any) |

Every row shares the same field set whether `deepScrape` is on or off — the fields marked "deep mode" above are filled in from the listing's own detail page, and stay `null`/empty rather than fabricated when `deepScrape` is off.

***

### How to use Facebook Marketplace Scraper

Anyone who wants to scrape Facebook Marketplace listings as clean JSON — instead of scrolling and copying — can run this actor against one or more search URLs and get every result back as structured rows.

**Copy to your AI assistant:**

```text
facebook-marketplace-scraper is an Apify Actor that returns Facebook Marketplace search results as structured JSON: listing title, price, photos, condition, description, seller name, and location. Use it whenever someone needs Facebook Marketplace listing data without cookies, a login, or a browser - tracking resale prices for a product category, building a local classifieds feed, or feeding listing text into an LLM-based deal finder. Run it with curl: curl -X POST "https://api.apify.com/v2/acts/facebook-marketplace-scraper/run-sync-get-dataset-items?token=APIFY_TOKEN" -H "Content-Type: application/json" -d '{"urls":["https://www.facebook.com/marketplace/108479165840750/search/?query=phone&exact=false"],"count":20,"deepScrape":true}'. Or in Python: ApifyClient("APIFY_TOKEN").actor("facebook-marketplace-scraper").call(run_input={...}) then client.dataset(run["defaultDatasetId"]).list_items().items. Inputs: urls (array, required, one or more Facebook Marketplace search URLs), count (integer, default 20, listings per URL, 0 for as many as can be found), deepScrape (boolean, default true, opens each listing's own page for extra fields), proxyConfiguration (object, proxy settings, residential recommended). Facebook only server-renders a first page of results to a logged-out visitor; this actor works past that cap using Facebook's own search filters, so very large count values depend on how many distinct filter combinations a given search actually returns. Full input schema, every default, and the complete output field list: GET https://api.apify.com/v2/acts/facebook-marketplace-scraper/builds/default
```

#### Facebook Marketplace Scraper MCP Server: use these Actors from ChatGPT, Claude or Cursor

Point your AI assistant at the actor and it can read Facebook Marketplace on its own: listings, prices, photos, seller info, and listing detail fields. No glue code, no scraping logic in your prompts.

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Step by step

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open Facebook Marketplace Scraper in the Apify Store.
3. Enter one or more Facebook Marketplace search URLs.
4. Click **Start**.
5. Download or stream your results in JSON, CSV or Excel — this is how you export Facebook Marketplace listings to csv straight from the Storage/Output tab.

#### How to scale Facebook Marketplace Scraper to bulk

`urls` is an array, so a single run of this bulk Facebook Marketplace scraper can hold many search URLs at once — different queries, cities, or categories — and each one is paginated independently up to your `count` cap. There's no separate bulk input mode: scaling up just means adding more lines to `urls`, or scheduling repeated runs for ongoing price monitoring.

***

### ✨ Features

Facebook Marketplace Scraper fetches clean, structured listings from Facebook Marketplace ⚡ at a simple per-row cost 💸. It's ideal for reselling research, local-market price tracking, classifieds aggregation, and AI deal-finder agents — acting as a Facebook Marketplace data extractor that hands back typed rows instead of raw HTML. It extracts, per listing:

- **Title** – the listing's headline, as the seller wrote it
- **Price** – the asking price, plus any discount (strikethrough) price
- **Photo gallery** – every photo, full-size, once deep mode has run
- **Condition** – the seller's condition label (deep mode)
- **Description** – the full listing text (deep mode)
- **Location** – approximate city/state, with map coordinates in deep mode
- **Seller** – the seller's public name and profile id, which also makes this a usable Facebook Marketplace seller scraper for tracking who's listing what
- **Status flags** – sold, live, pending, hidden

⚡ Switches to a fresh connection automatically on a block, so one blocked request doesn't stall the rest of a run.

***

### Use cases 💡

- **Reseller** — shortlist underpriced used items by `condition` and price before making an offer.
- **Market researcher** — run this facebook marketplace price scraper on repeat runs to chart how asking prices move over time.
- **Classifieds aggregator** — rebuild a searchable local-marketplace feed from `location` and the photo gallery.
- **Product researcher** — compare `description` and structured attributes to see what condition and specs sellers actually list at.
- **AI agent builder** — feed `marketplace_listing_title`, `description`, and `listing_price` into an LLM prompt to rank listings by value.

Building an AI agent? [Connect Facebook Marketplace Scraper over MCP](#facebook-marketplace-scraper-mcp-server-use-these-actors-from-chatgpt-claude-or-cursor) and let it call the actor on its own.

***

### Why choose this actor?

1. **Deep-mode detail, measured on a real run.** A recorded run against a live Facebook Marketplace search URL returned 3 full listings — title, price, photos, condition, description, structured attributes, seller, and map coordinates — in 8.1 seconds, with the first listing landing in the dataset after 5.3 seconds rather than only once every listing was done.
2. **One listing, every field Facebook shows.** That same recorded listing came back with a formatted price, a discount (strikethrough) price, a condition label, a full description, structured attributes (brand, condition code), and the seller's public name and id — all in one JSON row.
3. **One input, many search combinations.** `urls` takes as many Facebook Marketplace search URLs as you want in a single run — different queries, cities, or categories — each paginated and expanded independently past Facebook's own first-page cap.

***

### ⬇️ Input

Facebook Marketplace Scraper accepts one or more Facebook Marketplace search URLs. `urls` is the only required field.

| Parameter | Required | Type | Description | Example value |
| --- | --- | --- | --- | --- |
| `urls` | **Yes** | array | One or more Facebook Marketplace search URLs to scrape, one per line. | `["https://www.facebook.com/marketplace/108479165840750/search/?query=phone&exact=false"]` |
| `count` | No | integer | Maximum listings to collect per URL. Default `20`. Use `0` for as many as can be found. Free plan users are limited to 20 items per input and 200 items per month; paid plans have no limit. | `20` |
| `deepScrape` | No | boolean | `true` (default) opens each listing's own page to fill in extra fields (condition, description, structured attributes, posting time, full photo gallery, map coordinates) and seller details; `false` returns faster, search-result-only fields. | `true` |
| `proxyConfiguration` | No | object | Proxy used for every request. Residential is recommended, since Facebook routinely blocks non-residential IPs. | `{ "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }` |

#### Example input

```json
{
  "urls": [
    "https://www.facebook.com/marketplace/108479165840750/search/?query=phone&exact=false"
  ],
  "count": 20,
  "deepScrape": true,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }
}
```

***

### ⬆️ Output

Facebook Marketplace Scraper pushes one flat, typed JSON row per listing to the run's default dataset — the schema is the same regardless of `deepScrape`; the fields only a listing's own detail page provides are `null` or empty when `deepScrape` is off. Export directly from the **Storage/Output** tab as JSON, CSV, or Excel, or read it through the Apify API/SDK.

#### Example output

```json
{
  "facebookUrl": "https://www.facebook.com/marketplace/108479165840750/search/?query=phone",
  "listingUrl": "https://www.facebook.com/marketplace/item/1073863072201531",
  "id": "1073863072201531",
  "primary_listing_photo": {
    "__typename": "CatalogMarketplaceEnhancementTransformedImage",
    "id": "2388170854925054",
    "photo_image_url": "https://scontent.xx.fbcdn.net/v/photo1.jpg"
  },
  "listing_photos": [
    {
      "__typename": "CatalogMarketplaceEnhancementTransformedImage",
      "accessibility_caption": "No photo description available.",
      "image": { "height": 960, "width": 720, "uri": "https://scontent.xx.fbcdn.net/v/photo1.jpg" },
      "id": "2388170854925054"
    }
  ],
  "listing_price": { "formatted_amount": "BDT6,500", "amount_with_offset_in_currency": "5242", "amount": "6500.00" },
  "strikethrough_price": { "formatted_amount": "BDT8,000", "amount": "8000.00" },
  "comparable_price": null,
  "comparable_price_type": null,
  "location": {
    "reverse_geocode": { "city": "Rajshahi", "state": "", "city_page": { "display_name": "Rajshahi", "id": "108479165840750" } },
    "latitude": 24.364929199219,
    "longitude": 88.599243164062
  },
  "condition": "Used – good",
  "description": { "text": "Emergency Takar proyjon, Phone Smooth Ache, Er Aghe Original Display taa Chaap lege Nosto hoye Gechilo pore Medium Quality  Display taah lagaychi, Battery backup Medium rat ay charge diye ghumay jay are sokal theke sondha pojonto used hoy, Taa chara sob ok ache, \n\nRam 4 GB \nRoom 128 GB \n\nJara phone taah nite icchuk taray sudhu Knock diben." },
  "listing_attributes": [
    { "attribute_name": "Condition", "value": "used_good", "label": "Used – good" }
  ],
  "timestamp": "2026-09-26T07:17:14.000Z",
  "is_hidden": false,
  "is_live": true,
  "is_pending": false,
  "is_sold": false,
  "is_viewer_seller": false,
  "min_listing_price": null,
  "max_listing_price": null,
  "marketplace_listing_category_id": "1557869527812749",
  "marketplace_listing_title": "Vivo S1 phone Sell",
  "custom_title": null,
  "custom_sub_titles_with_rendering_flags": [],
  "origin_group": null,
  "listing_video": null,
  "parent_listing": null,
  "marketplace_listing_seller": { "__typename": "User", "name": "Jane Doe", "id": "100000000000000" },
  "delivery_types": ["IN_PERSON"]
}
```

Note: `condition`, `description`, `listing_attributes`, `timestamp`, the full `listing_photos` gallery, and `location.latitude`/`location.longitude` are only populated when `deepScrape` is `true` (the default) — with `deepScrape: false` those same keys are present but `null`/empty, never fabricated. This example is a real recorded listing, exactly as returned, except the seller's name and profile id have been replaced with a placeholder to protect that individual's identity.

***

### How does it work?

On each run, Facebook Marketplace Scraper reads the listings already shown on the search page itself — the same data a logged-out visitor's own page load already contains, over plain HTTP requests rather than a browser. Since Facebook only shows a first page of results to a logged-out visitor, the actor repeats the same search using the filters Facebook's own interface already offers (price ranges, sort order, condition, listing age) and merges the de-duplicated results. In deep mode, it also opens each listing's own page to fill in the fields the search results leave out. Every request goes through a proxy, and a request that gets blocked automatically switches to a fresh connection and retries. Only data Facebook already serves to a logged-out visitor is ever returned, and the output schema stays the same even if Facebook changes its layout.

***

### How do you integrate Facebook Marketplace Scraper into your stack?

Facebook Marketplace Scraper works with what you already use: call it as a Facebook Marketplace listings API from any language, over MCP for AI agents, or through no-code automation tools.

#### Using Facebook Marketplace Scraper with the Apify API

```python
import requests

url = "https://api.apify.com/v2/acts/facebook-marketplace-scraper/run-sync-get-dataset-items"
resp = requests.post(url, params={"token": "APIFY_TOKEN"}, json={
    "urls": ["https://www.facebook.com/marketplace/108479165840750/search/?query=phone"],
    "count": 20,
    "deepScrape": True,
})
for item in resp.json():
    print(item["marketplace_listing_title"], item["listing_price"]["formatted_amount"])
```

*Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.*

#### MCP integration for AI agents

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

This registers Facebook Marketplace Scraper as a tool your agent can call directly. Compatible with Claude Code, Cursor, and Windsurf.

#### No-code tools (n8n, Make, LangChain)

In **n8n**, use the Apify node's "Run Actor and get dataset" operation pointed at `facebook-marketplace-scraper`. In **Make**, add the Apify app's "Run an Actor" module with the same Actor ID and map the output dataset into your scenario. In **LangChain**, use `langchain-apify` and `ApifyActorsTool("facebook-marketplace-scraper")` to run the actor and load its dataset directly into a chain or agent.

***

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

Scraping publicly available data — data any logged-out visitor can already see — is generally lawful, and Facebook Marketplace Scraper only returns what a public search or listing page already shows. Marketplace listings are mostly product data (titles, prices, categories, descriptions), which falls under Facebook's terms of service and database-rights considerations rather than a personal-data regime. One exception: the seller name and profile id field can identify a private individual, so storing it in bulk may bring GDPR/CCPA-style personal-data obligations specifically for that field. Consult legal counsel if your use case involves bulk storage of personal data.

***

### Frequently asked questions

#### What fields does Facebook Marketplace Scraper return?

The top fields are listing title, price, photos, condition, and location. See the full [data fields section](#what-data-can-i-extract-with-facebook-marketplace-scraper) above.

#### Does Facebook Marketplace Scraper require a Facebook account or login?

No. Only public listing data is extracted — this is a Facebook Marketplace scraper no login setup needs: no username, password, or cookie from you, ever.

#### How fast does Facebook Marketplace Scraper run?

In a recorded run, one search URL returned 3 listings (deep mode, every detail-page field filled in) in 8.1 seconds total, with the first listing already in the dataset after 5.3 seconds. Every run reads live data, not a cached copy.

#### What happens if a listing is private, removed, or sold?

A sold listing is still returned with `is_sold` set to `true` rather than dropped, so you can filter on that flag. A listing that no longer resolves at all (deleted or inaccessible) simply isn't collected — the actor never fabricates a placeholder row for it.

#### Can I scrape multiple Facebook Marketplace URLs at once?

Yes. `urls` accepts an array, so one run of this facebook marketplace search scraper can process many search URLs — different queries, cities, or categories — each paginated and expanded independently.

#### Does Facebook Marketplace Scraper work with Claude, ChatGPT, and other AI agent tools?

Yes — it's reachable through Apify's MCP server. Run `claude mcp add --transport http apify "https://mcp.apify.com"` to register it in Claude Code, Cursor, or Windsurf. Any agent that can call an HTTP endpoint can also use the REST API directly.

#### How does Facebook Marketplace Scraper compare to other Facebook Marketplace scrapers?

As observed on the Apify Store on 2026-10-10, Apify's own Facebook Marketplace Scraper prices deep-scrape listing access from $2.60 per 1,000 listings. Facebook Marketplace Scraper returns a comparable field set in quick mode and a comparably detailed record in deep mode, billed simply per dataset row (`row_result`) rather than a separate tiered event.

#### Does Facebook Marketplace Scraper return data in a format LLMs can use directly?

Yes. Output is typed, normalized JSON with consistent field names across runs — no HTML parsing or CSS selectors involved. Pass it directly to an LLM prompt, index it into a vector store, or feed it to an agent tool.

#### What happens when Facebook changes its layout or anti-bot system?

The actor re-reads what it needs directly from Facebook's own live pages on every run rather than hardcoding a copy, so it's built to keep working through routine Facebook changes, with the same output schema. No specific turnaround time is promised for deeper structural changes.

#### Can I use Facebook Marketplace Scraper without managing proxies or browser infrastructure?

Yes. Proxy rotation and the switch to a fresh connection on a block both happen automatically; you can optionally choose your own proxy settings via `proxyConfiguration`, or leave the residential default in place. There's no browser to manage either — every request goes to Facebook's own pages directly over HTTP.

#### Which Facebook Marketplace listing fields work best for AI training data and RAG indexing?

For RAG, index the description, listing title, and structured attributes — the highest-information text fields. For training or scoring pipelines, price, condition, and posting time come back as consistently typed primitives across every listing.

***

### Your feedback

Found a bug or a field that doesn't match what Facebook actually returns? Let us know via the **Issues** tab on this actor's Apify Console page so it can be checked and fixed. Feedback like this is what keeps the field list and extraction logic accurate as Facebook changes its site.

# Actor input Schema

## `urls` (type: `array`):

One or more Facebook Marketplace search URLs, one per line. Example: https://www.facebook.com/marketplace/108479165840750/search/?query=phone

## `count` (type: `integer`):

Maximum listings to collect per URL. Use 0 for as many as can be found. Free plan users are limited to 20 items per input and 200 items per month; paid plans have no limit.

## `deepScrape` (type: `boolean`):

ON (default): also opens each listing's own page to fill in extra fields (condition, description, structured attributes, posting time, full photo gallery, map coordinates) and seller details. OFF: faster, search-results-only fields.

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

Proxy used for every request. Residential is recommended, since Facebook routinely blocks non-residential IPs.

## Actor input object example

```json
{
  "urls": [
    "https://www.facebook.com/marketplace/108479165840750/search/?query=phone&exact=false"
  ],
  "count": 20,
  "deepScrape": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

All scraped listings.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "urls": [
        "https://www.facebook.com/marketplace/108479165840750/search/?query=phone&exact=false"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("socialdataapi/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 = {
    "urls": ["https://www.facebook.com/marketplace/108479165840750/search/?query=phone&exact=false"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("socialdataapi/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 '{
  "urls": [
    "https://www.facebook.com/marketplace/108479165840750/search/?query=phone&exact=false"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call socialdataapi/facebook-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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