# Facebook Marketplace Property Scraper (`vivid-softwares/facebook-property-scraper`) Actor

Scrape Facebook Marketplace property listings fast. Extract detailed rental and sale data including prices, locations, descriptions, seller details, phone numbers, images, and listing URLs. Export to CSV, JSON, Excel, or use via API.

- **URL**: https://apify.com/vivid-softwares/facebook-property-scraper.md
- **Developed by:** [VividSoftwares](https://apify.com/vivid-softwares) (community)
- **Categories:** Lead generation, Real estate, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $18.00 / 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.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Facebook Marketplace Property Scraper - Property Listings Data API

🏠 Extract Facebook Marketplace rental and for-sale property listings with prices, locations, images, bedroom counts, bathroom counts, seller details, map data, and full listing details.

**Pay per result. Only pay for the Facebook Marketplace property listings successfully saved to your dataset.**

### 🎯 What This Scraper Does

Facebook Marketplace Property Scraper is an Apify actor for extracting property data from Facebook Marketplace. Paste a Facebook Marketplace property rentals or property-for-sale URL, run the actor, and get clean property listing data without opening every listing manually.

It is built for rental and sale property searches, rooms to rent, houses, flats, apartments, and other Marketplace property listings. The scraper scrolls Marketplace search feeds, collects listing URLs, opens listing detail pages, uses enhanced property matching and regex parsing to reduce missed listings, and saves normalized results to the default Apify dataset.

The actor combines feed data, listing-page data, Facebook Marketplace detail responses, visible property chips, and carefully tuned regex extraction. This helps capture listings even when Facebook shows important information in different places, such as the feed tile, image alt text, description, map section, or property details section.

### 📊 What Facebook Marketplace Property Data Can I Extract?

The actor extracts property-focused listing data that is useful for rental research, deal monitoring, lead generation, and local housing market analysis.

| Listing data | Property data | Location data |
| ------------ | ------------- | ------------- |
| Listing URL | Bedrooms | City |
| Listing ID / product ID | Bathrooms | Address text |
| Title | Property type | Latitude |
| Full description | Property features | Longitude |
| Price text | Parking availability | Approximate map radius |
| Numeric price | Garden availability | Marketplace location |
| Currency | Furnishing, tenure, and size details when visible | Location accuracy flag |
| Images | Listed and availability text | Google Maps URL |
| Seller details | Postcode and phone numbers when visible | Category URL |
| Listing category | Rental / sale intent | Scrape timestamp |

### ✨ Key Features

- 🔍 **Facebook Marketplace property feeds** - Designed specifically for Marketplace property rental and for-sale feeds, not generic product listings.
- 🧠 **Enhanced property searching** - Uses property-specific matching, feed prefiltering, detail-page checks, and regex patterns so relevant homes, rooms, flats, studios, and sale listings are less likely to be missed.
- 🧩 **Multi-source detail extraction** - Combines feed tiles, aria labels, image alt text, listing pages, JSON-LD, visible page sections, and Marketplace GraphQL detail responses for richer results.
- 🌍 **Location-based search URLs** - Use Marketplace category, city, radius, latitude, longitude, and filtered search URLs.
- 🏡 **Detailed property data** - Extract descriptions, images, location, beds, bathrooms, property type, square footage, postcodes, phone numbers, seller details, map coordinates, and property features when visible.
- 🎯 **Intent-focused filtering** - Keeps likely residential rental listings by default, or for-sale listings when `forSaleOnly` is enabled, while filtering obvious junk, commercial listings, sale/rent mismatches, and unrelated Marketplace items.
- ⚡ **Smart enrichment** - Saves strong feed matches quickly and opens detail pages only when more information is needed, keeping runs simple and efficient.
- 🔄 **Deduplication across runs** - Avoid reprocessing listings already seen in previous runs unless you enable duplicates.
- 📊 **Structured output** - Clean JSON, CSV, Excel, and API-ready data for spreadsheets, CRMs, dashboards, alerts, and databases.
- 🛡️ **Proxy support** - Uses Apify Proxy or your own proxy configuration for more reliable Facebook Marketplace access.
- ⏰ **Monitoring ready** - Schedule repeat runs to track new Marketplace rental listings in a target location.

### 🎯 Perfect For

- **Property investors** monitoring local rental supply and pricing.
- **Letting agents and estate agents** tracking Facebook Marketplace rental competition.
- **Deal sourcing teams** looking for new rental leads, rooms, houses, flats, and apartments.
- **Market researchers** building local housing datasets from public Marketplace listings.
- **Rental platforms and aggregators** collecting structured rental listing feeds.
- **Lead generation workflows** that need fresh property listing URLs and descriptions.
- **Price monitoring** for rent levels by city, search radius, property type, and bedroom count.

### 🚀 Quick Start

1. Open Facebook Marketplace in your browser.
2. Go to Property Rentals, Property for Sale, or create a filtered search for your target location.
3. Copy the Marketplace URL with the filters you want.
4. Paste the URL into `startUrls` on Apify.
5. Keep Apify Proxy enabled for better reliability.
6. Click **Start** and download the dataset as JSON, CSV, Excel, or HTML.

### 🔗 Supported Facebook Marketplace URLs

Use the exact Marketplace URL that already contains your location, category, query, radius, or filters.

```text
https://www.facebook.com/marketplace/category/propertyrentals
https://www.facebook.com/marketplace/113013485375759/propertyforsale
https://www.facebook.com/marketplace/london/propertyrentals
https://www.facebook.com/marketplace/category/propertyrentals?exact=false&latitude=53.7567&longitude=-0.3589&radius=13
https://www.facebook.com/marketplace/london/search/?query=studio%20flat
https://www.facebook.com/marketplace/item/123456789012345
````

For feed scraping, build the search on Facebook Marketplace first, verify the listings are the ones you want, then copy that URL into the actor. You can also paste an individual listing URL when you only want to process that one item.

### ⚙️ Input

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/category/propertyrentals?exact=false&latitude=53.7567&longitude=-0.3589&radius=13"
    }
  ],
  "includeDuplicates": false,
  "rentalsOnly": true,
  "forSaleOnly": false,
  "enhancedListingDetails": true
}
```

### ⚙️ Input Options

| Field | Type | Default | Description |
| ----- | ---- | ------- | ----------- |
| `startUrls` | array | Required | One or more Facebook Marketplace property rental, for-sale, category, city, search, or individual listing URLs to scrape. |
| `includeDuplicates` | boolean | `false` | If `false`, listings already saved in previous runs are skipped. Set to `true` if you want every run to export all visible listings again. |
| `rentalsOnly` | boolean | `true` | Keeps likely residential rentals and skips sale-only or unrelated Marketplace items. |
| `forSaleOnly` | boolean | `false` | Keeps likely residential for-sale listings and skips rentals or unrelated Marketplace items. When enabled, this overrides `rentalsOnly`. |
| `enhancedListingDetails` | boolean | `true` | Opens each listing page for richer output such as seller info, descriptions, images, property chips, and map/location data. |

Proxy, browser tuning, concurrency, and debug controls are internal production settings. The actor runs headless with a tall, low-scale feed scanner viewport and Apify Residential Proxy enabled by default.

Each listing is saved **once** to the dataset. Beds, bathrooms, and property type are parsed from the feed tile title, aria-label, image alt text, visible property chips, and listing detail responses when present. The scraper also uses regex extraction for useful hidden-in-text details such as UK postcodes, square footage, phone numbers, rental phrases, sale phrases, room listings, studios, and multilingual property summaries.

With `enhancedListingDetails` enabled, the actor uses Marketplace detail data plus browser-visible listing sections to collect richer descriptions, seller details, property chips, images, map/location data, and availability text. It only opens listing pages that still need a full description or are missing bed/bath structure on the feed tile, so searches stay efficient while still capturing more complete data. Turn `enhancedListingDetails` off for the fastest feed-only export.

### 📊 Output Sample

Each result is saved as one structured property listing in the default dataset.

```json
{
  "url": "https://www.facebook.com/marketplace/item/1175613224586165",
  "id": "1175613224586165",
  "scrapedAt": "2026-05-24T22:57:43.190812+00:00",
  "address": "Kingston upon Hull, East Riding of Yorkshire, United Kingdom",
  "city": "Kingston upon Hull",
  "region": "East Riding of Yorkshire",
  "country": "United Kingdom",
  "postcode": "HU1 1AA",
  "latitude": 53.76273,
  "longitude": -0.35325,
  "googleMapsUrl": "https://www.google.com/maps/search/?api=1&query=53.76273,-0.35325",
  "isLocationApprox": true,
  "beds": "7",
  "bathrooms": "3",
  "property_type": "Room",
  "title": "Private room for rent",
  "description": "Spacious double room for rent and shared house. Close to shops, public links and restaurants.",
  "images": [
    "https://scontent-man2-1.xx.fbcdn.net/v/t39.30808-6/example.jpg"
  ],
  "listingCategory": "Property for rent",
  "listingIntent": "rent",
  "listedTimeText": "Listed over a week ago - Available now",
  "listedDateText": "Listed over a week ago",
  "availableDateText": "Available now",
  "seller": {
    "name": "Example Seller",
    "profileId": "123456789",
    "profileUrl": "https://www.facebook.com/marketplace/profile/123456789",
    "avatarUrl": "https://scontent.example/fb-avatar.jpg",
    "rating": 3.9,
    "ratingText": "3.9 out of 5 stars, from one review",
    "reviewCount": 1,
    "joinedFacebookYear": "2008",
    "joinedFacebookText": "Joined Facebook in 2008"
  },
  "detailSectionName": "Unit details",
  "propertyDetailItems": [
    "House",
    "7 beds - 3 baths",
    "Parking available",
    "Unfurnished",
    "Garden"
  ],
  "locationRadius": "2k",
  "mapImageUrl": "https://external-man2-1.xx.fbcdn.net/static_map.php?v=2068&center=53.76273,-0.35325&circle=...",
  "final_price": 475,
  "currency": "GBP",
  "parkingAvailable": true,
  "garden": true,
  "matchReason": "property_fields"
}
```

### 📋 Output Fields

| Field | Description |
| ----- | ----------- |
| `url` | Canonical Facebook Marketplace listing URL. Also used internally for deduplication history. |
| `id` | Facebook Marketplace listing ID. |
| `title` | Listing title from the feed or listing page. |
| `description` | Full listing description when available. |
| `final_price` | Numeric listing price when detected. |
| `currency` | Currency code, such as `GBP`, `USD`, or `EUR`. |
| `address` | Marketplace address or location text, using the most complete visible location when available. |
| `city` | Parsed city or primary location. |
| `region` | Parsed county/region/state when present in the location text. |
| `country` | Parsed country when present in the location text. |
| `postcode` | UK postcode detected from the address, details, title, or description when visible. |
| `latitude` | Approximate map latitude when Facebook exposes it. |
| `longitude` | Approximate map longitude when Facebook exposes it. |
| `googleMapsUrl` | Google Maps URL built from the approximate latitude and longitude. |
| `isLocationApprox` | Boolean indicating Facebook marked the map/location as approximate. |
| `beds` | Number of bedrooms, or `Studio` where detected. |
| `bathrooms` | Number of bathrooms. |
| `property_type` | House, flat, apartment, room, studio, or other detected type. |
| `squareFeet` | Square footage detected from visible details or description, when present. |
| `propertyDetailItems` | Raw property detail chips shown by Facebook Marketplace. |
| `parkingAvailable` | Boolean when parking is detected. |
| `garden` | Boolean when a garden is detected. |
| `images` | Array of listing image URLs. |
| `locationRadius` | Approximate map radius when Facebook exposes it. Coordinates are the center of Facebook's approximate map circle, not an exact street address. |
| `mapImageUrl` | Static map image URL when Facebook exposes it. |
| `listingCategory` | Facebook Marketplace category label. |
| `listingIntent` | Usually `rent` for property rental searches or `sale` for property-for-sale searches. |
| `listedTimeText` | Raw human-readable listed and availability text from Facebook. |
| `listedDateText` | Listed date/time text split from `listedTimeText`, when detected. |
| `availableDateText` | Availability date/time text split from `listedTimeText`, when detected. |
| `seller` | Seller information object when Facebook exposes it on the listing page. Can include `name`, `profileId`, `profileUrl`, `avatarUrl`, `rating`, `ratingText`, `reviewCount`, `joinedFacebookYear`, and `joinedFacebookText`. |
| `phoneNumbers` | Phone numbers detected in the visible description, when present. |
| `tenure` | Sale tenure such as freehold or leasehold when visible in property detail chips. |
| `energyRating` | Energy rating details when Facebook exposes them. |
| `externalUrl` | External advertiser URL when Facebook exposes one. |
| `virtualTourUrl` | Virtual tour URL when Facebook exposes one. |
| `is_live`, `is_pending`, `is_sold`, `is_draft`, `is_on_marketplace` | Listing status fields when available from Facebook detail data. |
| `scrapedAt` | Timestamp when the listing was saved. |
| `matchReason` | Internal reason the listing was kept as a property match. |

Some fields may be empty when Facebook does not show the data publicly for a listing, region, account state, or session.

Facebook usually labels map locations as approximate. The actor extracts the map center coordinates and radius (often `2k`) from the static map image URL. That is the most precise location Facebook exposes on the listing page — not a full street address.

### 🔄 How Deduplication Works

By default, the actor keeps a history of listing URLs for your Apify user and skips listings it has already seen. This makes scheduled runs more useful because each run can focus on fresh Marketplace rental listings.

Set `includeDuplicates` to `true` if you want every run to return listings even when they were already collected in a previous run.

### ⏰ Scheduling and Alerts

Facebook Marketplace moves quickly, especially for rooms, cheap flats, and short-term rentals. For monitoring workflows, schedule this actor to run repeatedly and connect the dataset to your alerting tool.

Popular workflows include:

- Send new rental listings to Google Sheets.
- Trigger Slack or Discord alerts for fresh Marketplace property matches.
- Push listings into a CRM for lead follow-up.
- Store results in a database for price tracking.
- Run daily market snapshots for local rental analysis.

### 🔌 API and Integrations

You can run this Facebook Marketplace Property Scraper manually in Apify Console, schedule it, or call it through the Apify API.

Results can be exported as:

- JSON
- CSV
- Excel
- XML
- HTML table
- API dataset items

You can integrate the actor with Apify webhooks, Zapier, Make, Google Sheets, Slack, Discord, Airbyte, GitHub, Google Drive, CRMs, databases, and custom Python or Node.js workflows.

### 💡 Tips for Best Results

- Use a Marketplace URL that already shows the location and filters you want.
- Match your proxy region to the Marketplace location where possible.
- Use Apify Proxy for more stable runs.
- If Facebook shows very few listings, try a narrower location, a different radius, or a saved browser session.
- Keep `includeDuplicates` set to `false` for scheduled monitoring.
- Use multiple `startUrls` to monitor several cities, search queries, or radius settings in one run.
- For rare listings, create overlapping searches with different radiuses or keywords.
- Use direct `/marketplace/item/...` URLs when you want to enrich or test a single listing.
- Keep `enhancedListingDetails` enabled when you want the best chance of capturing descriptions, property chips, seller data, map data, postcodes, square footage, and availability text.

### 🔧 Use Cases & Examples

#### 🏘️ Rental Market Research

Track asking rents, bedroom counts, property types, and Marketplace supply across a target city or postcode area.

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/category/propertyrentals?exact=false&latitude=51.5072&longitude=-0.1276&radius=10"
    }
  ],
  "includeDuplicates": false
}
```

#### 🏠 Room Rental Lead Generation

Monitor new rooms and shared house listings so you can contact advertisers quickly.

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/london/search/?query=room%20for%20rent"
    }
  ],
  "includeDuplicates": false
}
```

#### 📍 Multi-Location Property Monitoring

Run several Marketplace property searches together and export one combined dataset.

```json
{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/manchester/propertyrentals"
    },
    {
      "url": "https://www.facebook.com/marketplace/birmingham/propertyrentals"
    },
    {
      "url": "https://www.facebook.com/marketplace/leeds/propertyrentals"
    }
  ],
  "includeDuplicates": false
}
```

### 🌟 Why Choose This Scraper?

#### ✅ Built For Property Listings

Many Marketplace scrapers are designed for cars, electronics, or general products. This actor focuses on rental and property-specific fields such as beds, bathrooms, property type, rental/sale intent, location, postcodes, seller details, features, and property detail chips.

It also uses enhanced regex-based property matching to spot homes, rooms, studios, flats, apartments, houses, rental keywords, sale keywords, postcodes, square footage, and other useful details even when Facebook places them inside titles, image alt text, descriptions, or property chips.

#### ✅ Easy To Use

You do not need to build a Facebook API integration or manually open each listing. Copy a Marketplace property URL, paste it into `startUrls`, run the actor, and export the dataset.

The actor handles scrolling, listing discovery, duplicate checks, rental/sale filtering, detail enrichment, and clean output formatting for you.

#### ✅ Monitoring Ready

Deduplication across runs makes the actor useful for ongoing rental alerts and market tracking, not just one-off scraping.

#### ✅ Developer Friendly

The output is clean JSON with stable field names, nested seller data, normalized location fields, Google Maps links, and CSV-friendly values, making it easy to connect to spreadsheets, dashboards, databases, and custom automations.

#### ✅ Pay-Per-Result Pricing

This actor is designed for pay-per-result usage. You only pay for listings that are successfully extracted and saved to the dataset, making it practical for one-off searches, testing new locations, and ongoing Marketplace monitoring.

### 💼 Pricing & Usage

**Pay Per Result Benefits:**

- ✅ **Only pay for saved results** - You are charged based on extracted listings, not empty runs.
- ✅ **Good for testing locations** - Try different Marketplace URLs, cities, radiuses, and search queries without committing to a subscription.
- ✅ **Works for monitoring** - Schedule runs and use deduplication to focus on newly discovered listings.
- ✅ **Full property output** - Get listing URLs, prices, descriptions, images, location data, beds, bathrooms, and property features when available.
- ✅ **Apify exports included** - Download results as JSON, CSV, Excel, XML, HTML, or access them through the Apify API.

Perfect for:

- One-off Facebook Marketplace rental research
- Local property lead generation
- Rental price monitoring
- Multi-location market snapshots
- Automated alerting workflows

### ❓ FAQ

#### Does Facebook Marketplace have an official API for rental listings?

Facebook Marketplace does not provide a public API for collecting Marketplace rental listings at scale. This actor gives you structured access to publicly visible Marketplace property data through Apify.

#### Can I scrape Facebook Marketplace property rentals by location?

Yes. Create a Marketplace property rental search with your target city, radius, latitude, longitude, or search query, then paste that URL into `startUrls`.

#### Can I export Facebook Marketplace rental listings to CSV or Excel?

Yes. Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, and HTML table formats.

#### Can I use this as a Facebook Marketplace property API?

Yes. Run the actor through the Apify API, then fetch the dataset items programmatically from your backend, script, or automation workflow.

#### Does it support scheduled runs?

Yes. Use Apify schedules to run the actor hourly, daily, or at any interval you choose. Keep deduplication enabled to focus on newly discovered property listings.

#### Why do some listings have missing fields?

Facebook Marketplace does not show every field for every listing, location, account state, or region. If Facebook does not expose a value publicly during the run, the corresponding output field may be empty.

#### Do I need proxies?

The actor uses Apify Residential Proxy internally for Marketplace access. Proxy settings are not exposed in the public input form.

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

This actor is intended for publicly available Marketplace listing data. Your results may still contain personal data or user-generated content, so you are responsible for using the data lawfully and respecting applicable privacy rules, platform terms, and local regulations. If you are unsure, consult a qualified legal professional.

### Related Actors

Looking for more property data? Check out these related actors:

- [OpenRent Property Scraper | Pay Per Result](https://apify.com/vivid-softwares/openrent-property-scraper) - Scrape property listings from OpenRent.co.uk.
- [SpareRoom Property Scraper | Unlimited Usage](https://apify.com/vivid-softwares/spareroom-scraper) - Scrape room and flatshare listings from SpareRoom.co.uk.
- [SpareRoom Property Scraper | Pay Per Result](https://apify.com/vivid-softwares/spareroom-property-scraper) - Scrape property listings from SpareRoom.co.uk.
- [Gumtree Property Scraper | Unlimited Usage](https://apify.com/vivid-softwares/gumtree-scraper) - Scrape property listings from Gumtree.com.
- [Gumtree Property Scraper | Pay Per Result](https://apify.com/vivid-softwares/gumtree-property-scraper) - Scrape property listings from Gumtree.com.

### Keywords

facebook marketplace property scraper, facebook marketplace rental scraper, facebook marketplace rentals API, scrape facebook marketplace property listings, facebook marketplace real estate scraper, marketplace property data, facebook marketplace houses for rent scraper, facebook marketplace rooms for rent scraper, facebook marketplace apartments scraper, rental property scraper, property data extraction, real estate scraping, Apify Facebook Marketplace scraper, Facebook Marketplace API, rental market analysis, property lead generation, housing market data, rental listing data, Facebook Marketplace CSV export, Facebook Marketplace JSON export

### License

MIT

# Actor input Schema

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

Paste one or more Facebook Marketplace property rental URLs, location-scoped for-sale URLs such as /marketplace/{locationId}/propertyforsale, or individual /marketplace/item/ listing URLs. Feed URLs are scrolled; direct listing URLs are opened and saved individually.

## `includeDuplicates` (type: `boolean`):

If enabled, listings already seen in previous runs are included again.

## `rentalsOnly` (type: `boolean`):

Keep likely residential rental listings and skip sale-only or non-property Marketplace items.

## `forSaleOnly` (type: `boolean`):

Keep likely residential for-sale listings and skip rental or non-property Marketplace items. When enabled, this overrides rentalsOnly.

## `enhancedListingDetails` (type: `boolean`):

Open each listing page to extract richer details such as seller, full description, images, property chips, and map data. Turn off for faster feed-only runs.

## Actor input object example

```json
{
  "startUrls": [],
  "includeDuplicates": false,
  "rentalsOnly": true,
  "forSaleOnly": false,
  "enhancedListingDetails": true
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("vivid-softwares/facebook-property-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("vivid-softwares/facebook-property-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 '{}' |
apify call vivid-softwares/facebook-property-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Marketplace Property Scraper",
        "description": "Scrape Facebook Marketplace property listings fast. Extract detailed rental and sale data including prices, locations, descriptions, seller details, phone numbers, images, and listing URLs. Export to CSV, JSON, Excel, or use via API.",
        "version": "0.0",
        "x-build-id": "7kkQksRCREutZ5Frk"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vivid-softwares~facebook-property-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vivid-softwares-facebook-property-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/vivid-softwares~facebook-property-scraper/runs": {
            "post": {
                "operationId": "runs-sync-vivid-softwares-facebook-property-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/vivid-softwares~facebook-property-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-vivid-softwares-facebook-property-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": "Start URLs",
                        "type": "array",
                        "description": "Paste one or more Facebook Marketplace property rental URLs, location-scoped for-sale URLs such as /marketplace/{locationId}/propertyforsale, or individual /marketplace/item/ listing URLs. Feed URLs are scrolled; direct listing URLs are opened and saved individually.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDuplicates": {
                        "title": "Include duplicates",
                        "type": "boolean",
                        "description": "If enabled, listings already seen in previous runs are included again.",
                        "default": false
                    },
                    "rentalsOnly": {
                        "title": "Rentals only",
                        "type": "boolean",
                        "description": "Keep likely residential rental listings and skip sale-only or non-property Marketplace items.",
                        "default": true
                    },
                    "forSaleOnly": {
                        "title": "For sale only",
                        "type": "boolean",
                        "description": "Keep likely residential for-sale listings and skip rental or non-property Marketplace items. When enabled, this overrides rentalsOnly.",
                        "default": false
                    },
                    "enhancedListingDetails": {
                        "title": "Enhanced listing details",
                        "type": "boolean",
                        "description": "Open each listing page to extract richer details such as seller, full description, images, property chips, and map data. Turn off for faster feed-only runs.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```