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

Extract public Facebook Marketplace listings from search, city, and category URLs with prices, images, locations, and listing IDs.

- **URL**: https://apify.com/fetch\_cat/facebook-marketplace-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Social media, E-commerce, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 item processeds

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Facebook Marketplace Scraper

Scrape public Facebook Marketplace listings from search, city, and category URLs. Export listing IDs, URLs, titles, prices, locations, and images to CSV, JSON, Excel, datasets, API workflows, and AI agents.

Use this Actor to monitor local resale inventory, compare asking prices, collect marketplace leads, or feed internal deal-tracking workflows without managing browser automation yourself.

### At a glance

- **Primary job**: Extract public Facebook Marketplace listing rows from Marketplace URLs.
- **Input**: Paste one or more public Marketplace search, city, category, or listing URLs and set a listing limit.
- **Output**: One dataset row per listing with URL, ID, title, price, location, image, source URL, and scrape timestamp.
- **Best for**: Local inventory monitoring, resale research, competitive pricing, rental/property checks, and automation.

### Who is this for?

- **Resellers and buyers** tracking local asking prices and newly listed items.
- **Market researchers** collecting inventory samples across cities or categories.
- **Real estate and rental teams** monitoring public Marketplace property listings.
- **Automation teams** feeding public listing rows into alerts, CRMs, spreadsheets, or dashboards.

### Input recipes

Before public Apify example tasks exist, use these input recipes directly.

#### Used guitars in San Francisco

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar" }
  ],
  "maxItems": 25,
  "proxyConfiguration": { "useApifyProxy": true, "groups": ["RESIDENTIAL"] }
}
````

#### Laptops in New York City

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/marketplace/nyc/search/?query=laptop" }
  ],
  "maxItems": 25,
  "proxyConfiguration": { "useApifyProxy": true, "groups": ["RESIDENTIAL"] }
}
```

### What data can you extract?

| Field | Description |
| --- | --- |
| `id` | Facebook Marketplace listing ID. |
| `listingUrl` | Canonical Marketplace listing URL. |
| `sourceUrl` | Input URL where the listing was found. |
| `title` | Listing title when visible. |
| `priceText` | Displayed price text. |
| `priceAmount` | Parsed numeric price when possible. |
| `currency` | Parsed currency when possible. |
| `locationText` | Displayed listing location. |
| `city`, `state` | Parsed city and state/region when present. |
| `primaryImageUrl`, `imageUrls` | Public listing image URLs when available. |
| `sellerName`, `sellerId` | Public seller fields only when exposed in logged-out data. |
| `description`, `attributes`, `createdAt` | Detail fields reserved for public detail extraction. |
| `detailStatus` | Status of optional detail extraction. |
| `scrapedAt` | ISO timestamp when the row was saved. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Facebook Marketplace URLs | `startUrls` | Public Marketplace search, city, category, or listing routes. | `https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar` |
| Maximum listings | `maxItems` | Cap saved rows and control spend. | `50` |
| Proxy configuration | `proxyConfiguration` | Use Apify Proxy. Residential is recommended for Facebook Marketplace. | `{ "useApifyProxy": true, "groups": ["RESIDENTIAL"] }` |

### Example input

```json
{
  "startUrls": [
    { "url": "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar" }
  ],
  "maxItems": 25,
  "proxyConfiguration": { "useApifyProxy": true, "groups": ["RESIDENTIAL"] }
}
```

### Example output

```json
{
  "id": "1382249123799344",
  "listingUrl": "https://www.facebook.com/marketplace/item/1382249123799344/",
  "sourceUrl": "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar",
  "title": "Guitar San Francisco, CA",
  "priceText": "$80",
  "priceAmount": 80,
  "currency": "USD",
  "locationText": null,
  "city": null,
  "state": null,
  "primaryImageUrl": "https://scontent.example/listing.jpg",
  "imageUrls": ["https://scontent.example/listing.jpg"],
  "deliveryTypes": [],
  "isLive": null,
  "isPending": null,
  "isSold": null,
  "sellerName": null,
  "sellerId": null,
  "description": null,
  "attributes": {},
  "createdAt": null,
  "detailStatus": "not_requested",
  "scrapedAt": "2026-07-16T09:12:17.832Z"
}
```

### Pricing

This Actor uses pay-per-event pricing with a small run-start charge and tiered per-listing pricing. The current Store tiers are:

| Tier | Item processed price |
| --- | --- |
| Free | `$0.0115` |
| Bronze | `$0.0100` |
| Silver | `$0.0078` |
| Gold | `$0.0060` |
| Platinum | `$0.0040` |
| Diamond | `$0.0028` |

The `item` event is charged for each valid Marketplace listing row saved to the dataset.

### Tips for best results

- **Start small**: Use `maxItems: 25` until the route and output match your use case.
- **Use public Marketplace URLs**: The Actor does not use cookies, accounts, private messages, saved listings, or seller contact channels.
- **Choose focused searches**: Specific city and query URLs produce cleaner monitoring datasets than broad Marketplace home pages.
- **Schedule repeat runs**: Compare datasets over time to track price changes and new local inventory.

### API usage

Node.js:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/facebook-marketplace-scraper").call({
  startUrls: [{ url: "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar" }],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/facebook-marketplace-scraper").call(run_input={
    "startUrls": [{ "url": "https://www.facebook.com/marketplace/nyc/search/?query=laptop" }],
    "maxItems": 25,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~facebook-marketplace-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"}],"maxItems":25}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/facebook-marketplace-scraper"
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/facebook-marketplace-scraper"
    }
  }
}
```

Example prompt: "Run Facebook Marketplace Scraper for used guitars in San Francisco and summarize the listing prices."

### Limits and caveats

- **Public data only**: This Actor does not log in and does not collect private seller contact data or messages.
- **Availability varies**: Facebook can hide, remove, or change listing data at any time.
- **Anti-bot sensitivity**: Residential proxy is recommended. Very large or frequent runs may be throttled.
- **Optional fields**: Seller, status, and detail fields remain empty when not publicly exposed.

### Legality and responsible use

Process only data that you are allowed to access. Follow website terms, Apify's terms, and applicable laws.

### Related actors

- [Facebook Pages Scraper](https://apify.com/fetch_cat/facebook-pages-scraper)
- [Google Maps Places Scraper](https://apify.com/fetch_cat/google-maps-places-scraper)
- [Zillow Scraper](https://apify.com/fetch_cat/zillow-scraper)

### FAQ

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

#### Does this Actor need my Facebook account?

No. V1 is limited to public logged-out Marketplace data and does not accept cookies or credentials.

#### Why are some fields empty?

Some Marketplace fields are not exposed publicly on every route. The Actor leaves unavailable fields empty instead of guessing.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL.

# Actor input Schema

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

Public Marketplace search, category, location, or listing URLs to scrape.

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

Maximum number of listing rows to save across all start URLs.

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

Apify Proxy configuration. Residential proxy is recommended for Facebook Marketplace.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"
    },
    {
      "url": "https://www.facebook.com/marketplace/nyc/search/?query=laptop"
    }
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "groups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"
        },
        {
            "url": "https://www.facebook.com/marketplace/nyc/search/?query=laptop"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "groups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "startUrls": [
        { "url": "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar" },
        { "url": "https://www.facebook.com/marketplace/nyc/search/?query=laptop" },
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "groups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/facebook-marketplace-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/sanfrancisco/search/?query=guitar"
    },
    {
      "url": "https://www.facebook.com/marketplace/nyc/search/?query=laptop"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "groups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fetch_cat/facebook-marketplace-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/facebook-marketplace-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Marketplace Scraper",
        "description": "Extract public Facebook Marketplace listings from search, city, and category URLs with prices, images, locations, and listing IDs.",
        "version": "0.1",
        "x-build-id": "yubwxloSGoLVFL9Hh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~facebook-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-facebook-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/fetch_cat~facebook-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-facebook-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/fetch_cat~facebook-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-facebook-marketplace-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Facebook Marketplace URLs",
                        "type": "array",
                        "description": "Public Marketplace search, category, location, or listing URLs to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of listing rows to save across all start URLs.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify Proxy configuration. Residential proxy is recommended for Facebook Marketplace.",
                        "default": {
                            "useApifyProxy": true,
                            "groups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
