# Fast Facebook Marketplace Scraper ($1/k💰) (`karamelo/facebook-marketplace-scraper`) Actor

Scrape Facebook Marketplace listings by keyword or search URL without login. Extract product details, prices, locations, photos, and seller data into clean structured records. Cost-efficient  ($1/k💰)

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

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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: Reliable Local & Regional Product Data Extraction

Facebook Marketplace is one of the largest peer-to-peer and business commerce ecosystems in the world, connecting millions of local buyers and sellers daily across thousands of metropolitan areas. Whether you are tracking market pricing trends, sourcing profitable inventory for resale, monitoring local supply-demand fluctuations, or building real-time alerts for rare items, access to structured Marketplace data provides an unparalleled competitive edge.

The **Facebook Marketplace Scraper** is a production-grade Apify Actor designed to extract clean, standardized product listings from Facebook Marketplace at scale. It allows you to search by keyword query or scrape specific Marketplace category and search URLs without requiring personal accounts or session credentials. With customizable filters for location, pricing, item condition, recency, and delivery methods, this automation transforms unstructured local listings into clean, machine-readable datasets formatted in JSON, CSV, and Excel.

***

### Why Choose Facebook Marketplace Scraper?

- **Flexible Search Methods**: Run targeted keyword searches across any supported city or provide custom Facebook Marketplace search URLs directly.
- **Rich Multi-Attribute Filtering**: Refine listings by minimum and maximum price, listing age (last 24 hours, 7 days, or 30 days), item condition (new, like-new, good, fair), sorting preference, and delivery type.
- **Structured, Normalized Output**: Every record provides consistent top-level fields including listing title, price, geographical city/state, availability flags (sold, pending), photo URLs, category identifiers, and direct item URLs.
- **Fast, Lightweight Architecture**: Designed for rapid batch extraction and high throughput, enabling enterprise-scale monitoring without unnecessary execution overhead.
- **Enterprise Proxy Compatibility**: Fully compatible with Apify residential proxy infrastructure to maintain high availability and uninterrupted data collection across geographic regions.
- **No Personal Login Required**: Operates on public search results without requesting user credentials, eliminating account risk and ensuring effortless deployment into automated workflows.

***

### Practical Applications & Industry Use Cases

#### 1. Resale Arbitrage and Inventory Sourcing

Flippers, vintage curators, and refurbished electronics retailers leverage automated Marketplace feeds to identify mispriced goods the moment they appear. By setting up scheduled runs targeting specific electronics, instruments, designer apparel, or tools, sourcing specialists can contact sellers before competitors discover the listing.

#### 2. Local Market Intelligence and Price Benchmarking

Retailers, pawn shops, and liquidators use aggregated Marketplace data to understand prevailing second-hand market values for consumer electronics, furniture, appliances, and recreational vehicles across various metro areas. This pricing intelligence informs trade-in values and competitive retail pricing.

#### 3. Supply and Demand Regional Analytics

Market research analysts track listing volumes and turnover rates across different cities to measure consumer spending power, economic health, and geographic demand patterns for specific brands and equipment categories.

#### 4. Vehicle & Equipment Monitoring

Dealerships and independent brokers track private-party vehicle listings, farm machinery, trailers, and commercial equipment listed across suburban and rural jurisdictions, spotting high-margin buying opportunities within regional pickup radiuses.

#### 5. Academic & Economic Research

Economists and social scientists examine informal commerce dynamics, consumer behavior, durable goods lifecycles, and localized economic resilience using longitudinal Marketplace listing data.

***

### Supported Search Modes

The Actor supports two complementary modes of operation depending on your workflow requirements:

#### Mode A: Keyword Search with Location & Attribute Filters

Specify a `searchQuery` (such as `"mechanical keyboard"` or `"espresso machine"`) and choose your target `marketplaceLocation` (such as `"chicago"`, `"phoenix"`, or `"nyc"`). You can further customize your search by applying price boundaries, condition filters, and sorting parameters. The Actor automatically constructs the necessary search query and extracts matching listings.

#### Mode B: Direct Search URLs

If you have already configured a complex search on Facebook Marketplace with custom radius parameters or specific category trees, paste the full URL into the `startUrls` list. When `startUrls` are provided, they take immediate precedence over keyword filters, allowing you to replicate specific web searches directly.

***

### Complete Input Configuration Reference

The Actor accepts the following parameters through the Apify Console or JSON API payload:

| Parameter | Type | Default | Description |
| :--- | :--- | :--- | :--- |
| `searchQuery` | String | `"laptop"` | The primary keyword or search phrase to look up (e.g., `"standing desk"`, `"canon camera"`). |
| `marketplaceLocation` | String | `"chicago"` | City slug identifying the target marketplace geographic center (e.g., `"nyc"`, `"phoenix"`, `"losangeles"`, `"dallas"`). |
| `startUrls` | Array | `[]` | List of direct Marketplace search URLs. If supplied, URL scraping takes precedence over the keyword builder. |
| `sortBy` | String | `"best_match"` | Order in which listings are returned. Options: `"best_match"`, `"creation_time_descend"` (newest first), `"price_ascend"`, `"price_descend"`, `"distance_ascend"`. |
| `minPrice` | Integer | `0` | Minimum listing price threshold. Set to `0` for no minimum. |
| `maxPrice` | Integer | `0` | Maximum listing price threshold. Set to `0` for no upper ceiling. |
| `daysSinceListed` | String | `"0"` | Recency filter. Values: `"0"` (Any time), `"1"` (Last 24 hours), `"7"` (Last 7 days), `"30"` (Last 30 days). |
| `deliveryMethod` | String | `"all"` | Delivery options filter. Values: `"all"`, `"local_pick_up"` (Local pick up only), `"shipping"` (Shipping only). |
| `conditionNew` | Boolean | `false` | When enabled, filters results to include items listed in brand-new condition. |
| `conditionUsedLikeNew` | Boolean | `false` | When enabled, includes items listed as used in like-new condition. |
| `conditionUsedGood` | Boolean | `false` | When enabled, includes items listed as used in good condition. |
| `conditionUsedFair` | Boolean | `false` | When enabled, includes items listed as used in fair condition. |
| `exact` | Boolean | `false` | When enabled, instructs the search engine to match keyword phrases more strictly. |
| `maxItems` | Integer | `50` | Maximum total listings to collect and store in the dataset during a single run. |
| `proxyConfiguration` | Object | `{ "useApifyProxy": true }` | Apify Proxy configuration settings. Residential proxies are recommended for Facebook Marketplace. |

***

### Output Data Schema

Each scraped listing produces a flat, structured dataset record containing the following verified fields:

| Field | Data Type | Description |
| :--- | :--- | :--- |
| `id` | String | The unique numeric identifier assigned to the listing by Facebook. |
| `title` | String | The listing headline or title set by the seller. |
| `custom_title` | String / Null | Custom title or secondary headline when specified. |
| `price` | String | The human-readable formatted price string (e.g., `"$120"`, `"$450"`, or `"N/A"` for free/unspecified items). |
| `price_amount` | Number / Null | Numerical parsed price amount (e.g. `120.00`). |
| `listing_price` | Object / Null | Detailed price object containing `formatted_amount`, `amount`, and `amount_with_offset_in_currency`. |
| `strikethrough_price` | String / Null | Formatted original price before discounts, if discounted. |
| `location` | String / Null | Reverse-geocoded location representing the seller's city and state (e.g., `"Chicago, IL"`). |
| `location_details` | Object / Null | Detailed location object with `city`, `state`, and `display_name`. |
| `is_sold` | Boolean | Indicates whether the seller has marked the item as sold. |
| `is_pending` | Boolean | Indicates whether a sale agreement is currently pending for this item. |
| `is_live` | Boolean | Indicates whether the listing is currently active and live on Marketplace. |
| `is_hidden` | Boolean | Indicates whether the listing is hidden or delisted. |
| `creation_time` | Integer / Null | Unix epoch timestamp indicating when the listing was first published. |
| `timestamp` | String / Null | ISO 8601 formatted publication timestamp. |
| `image_url` | String / Null | Direct CDN URL for the primary high-resolution photograph of the product. |
| `delivery_types` | Array | List of available delivery and pickup mechanisms, such as `["IN_PERSON"]`, `["DOOR_PICKUP"]`, or `["SHIPPING"]`. |
| `category_id` | String / Null | Facebook internal category classification identifier for the product group. |
| `subtitle` | String / Null | Listing subtitle or badge text (e.g., Dealership, mileage) when available. |
| `seller` | Object / Null | Seller profile metadata containing `name` and `id` when made publicly accessible. |
| `marketplace_url` | String | Direct canonical URL to the item page on Facebook Marketplace. |

***

### Sample Input Examples

#### Example 1: Sourcing Refurbished Laptops in Chicago

```json
{
  "searchQuery": "thinkpad laptop",
  "marketplaceLocation": "chicago",
  "minPrice": 150,
  "maxPrice": 600,
  "sortBy": "creation_time_descend",
  "daysSinceListed": "7",
  "conditionUsedGood": true,
  "conditionUsedLikeNew": true,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

#### Example 2: Finding Vintage Audio Equipment with Shipping

```json
{
  "searchQuery": "turntable vinyl",
  "marketplaceLocation": "nyc",
  "deliveryMethod": "shipping",
  "minPrice": 50,
  "maxPrice": 350,
  "sortBy": "best_match",
  "maxItems": 40,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

#### Example 3: Scraping a Pre-Configured Marketplace URL

```json
{
  "startUrls": [
    "https://www.facebook.com/marketplace/phoenix/search/?query=gaming%20pc&maxPrice=1200"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

***

### Sample Output Record

The following is an illustrative record generated from a live search run:

```json
{
  "id": "1366679091707195",
  "title": "Vintage SLR Camera and 50mm Lens Kit",
  "custom_title": "Vintage SLR Kit",
  "price": "$175",
  "price_amount": 175,
  "listing_price": {
    "formatted_amount": "$175",
    "amount_with_offset_in_currency": "17500",
    "amount": "175.00"
  },
  "strikethrough_price": "$220",
  "location": "Chicago, IL",
  "location_details": {
    "city": "Chicago",
    "state": "IL",
    "display_name": "Chicago, Illinois"
  },
  "is_sold": false,
  "is_pending": false,
  "is_live": true,
  "is_hidden": false,
  "creation_time": 1787135313,
  "timestamp": "2026-08-19T10:28:33.000Z",
  "image_url": "https://scontent-lga3-3.xx.fbcdn.net/v/t39.84726-6/sample_camera_photo.jpg?stp=c0.0.261.261a_dst-jpg_p261x260_tt6&_nc_cat=106&ccb=1-7",
  "delivery_types": [
    "IN_PERSON",
    "DOOR_PICKUP"
  ],
  "category_id": "393860164117441",
  "subtitle": "Vintage Photography",
  "seller": {
    "name": "David Miller",
    "id": "100084729104821"
  },
  "marketplace_url": "https://www.facebook.com/marketplace/item/1366679091707195/"
}
```

***

### Step-by-Step Quick Start Guide

#### Step 1: Open the Actor in Apify Console

Navigate to the Actor's store page and click **Try for free** or **Run**.

#### Step 2: Define Your Search Query and Location

- Enter your search term in the **Search Query** field (e.g., `"road bike"`).
- Enter the target metropolitan area in the **Location City** field (e.g., `"losangeles"`, `"chicago"`, `"miami"`, or `"toronto"`).

#### Step 3: Apply Desired Price and Condition Filters

- Set **Minimum Price** and **Maximum Price** to eliminate unwanted budget or irrelevant high-end items.
- Check the relevant condition boxes if you only want brand-new or gently-used items.

#### Step 4: Configure Execution Limits

- Set **Maximum Items** to specify how many records to extract (e.g., `50` for quick alerts, `500` for deep regional scans).
- Ensure the **Proxy configuration** is enabled with Apify Residential proxies for consistent connectivity.

#### Step 5: Start the Run & Export Data

Click the green **Save & Run** button. Monitor real-time progress in the console log. Once finished, navigate to the **Dataset** tab to view your records in an interactive grid, or download the dataset as CSV, JSON, or Excel.

***

### Data Export and Downstream Integrations

The dataset generated by this Actor connects seamlessly with standard data pipelines, analytics suites, and automation platforms:

#### 1. Direct Downloads

Export collected listings instantly from the Apify Console in multiple formats:

- **JSON**: Ideal for developers building custom web apps or database sync scripts.
- **CSV / Excel**: Ready for spreadsheet analysis, pivot tables, and retail pricing models.
- **XML / RSS**: Useful for legacy feed ingestion and syndication systems.

#### 2. Apify REST API

Trigger runs programmatically and fetch results via standard HTTP requests:

```bash
// Fetch latest dataset items via API
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json&token=<YOUR_API_TOKEN>"
```

#### 3. Zapier, Make & n8n Automation

Set up automatic webhooks that trigger when a run finishes. Send new listing notifications directly to:

- **Slack / Discord**: Get immediate alerts for newly-listed target inventory.
- **Google Sheets / Airtable**: Maintain a persistent inventory tracking ledger.
- **Email Notifications**: Receive daily digests of top local deals.

***

### Best Practices for High-Volume Scraping

- **Use Residential Proxies**: Facebook Marketplace employs strict geographic and behavioral network filters. Always use Apify Residential proxies configured for the United States or the target country of your search.
- **Keep Max Items Proportionate**: Setting `maxItems` between 50 and 200 per city yields the freshest and most relevant items quickly. For broad geographic sweeps, create multiple smaller Actor tasks covering distinct cities rather than running a single massive crawl.
- **Combine Recency with Scheduling**: If you are monitoring for new deals, set `daysSinceListed` to `"1"` (last 24 hours) or `sortBy` to `"creation_time_descend"` and schedule the Actor to run every few hours. This minimizes duplicate processing and ensures you catch new items as soon as they appear.
- **Clean Location Slugs**: Always use standard city slugs without punctuation (e.g., use `"sanfrancisco"` instead of `"San Francisco, CA"`).

***

### Operational Limitations and Platform Guardrails

- **Public Marketplace Scope**: This Actor collects publicly available Marketplace listings. Private Facebook groups, member-only trade feeds, and listings behind user authentication walls are not accessible.
- **Seller Profile Visibility**: Facebook dynamically controls seller profile exposure on public search feeds. If a seller has opted out of public indexing, the `seller` field may return `null` while preserving the full listing details, price, location, and photos.
- **Geographic Radius Behavior**: When searching a city slug, Facebook determines the search radius around that urban center based on its internal density metrics (typically 40–100 km). Highly rural locations may show listings from neighboring regional hubs.
- **Real-Time Inventory Changes**: Marketplace items can be marked as sold or deleted by sellers at any moment. While the Actor captures the status flag (`is_sold`, `is_pending`) at the time of scrape, real-time availability should be verified before finalizing transactions.

***

### Troubleshooting & Diagnostics

#### Issue: "Actor finished with zero items collected"

- **Cause 1**: The search query may be too narrow or combined with overly restrictive price filters.
- **Solution**: Test a broader search term and set `minPrice` / `maxPrice` to `0` to verify listing availability in the target city.
- **Cause 2**: A non-standard city name was entered.
- **Solution**: Verify that the city slug corresponds to a recognized Facebook Marketplace directory name (e.g., `"chicago"`, `"phoenix"`, `"dallas"`).

#### Issue: "Prices showing as N/A"

- **Explanation**: Some sellers list items as free, make-an-offer, or fail to enter a numerical value. In these instances, the Actor faithfully records `"N/A"` to preserve dataset integrity rather than guessing arbitrary amounts.

#### Issue: "Connection errors during crawl"

- **Solution**: Ensure Apify Residential proxies are selected in your proxy configuration. Datacenter proxies are frequently blocked by social media platforms and should not be used for Marketplace data extraction.

***

### Frequently Asked Questions (FAQ)

##### Do I need to provide my Facebook username and password?

No. The Actor operates entirely without personal login credentials or account cookies, ensuring safe and risk-free operation.

##### Can I search in countries outside the United States?

Yes. You can target international cities that support Facebook Marketplace (such as `"london"`, `"toronto"`, `"sydney"`, or `"melbourne"`) by entering their respective slug in the `marketplaceLocation` parameter.

##### How frequently can I run the scraper?

You can run the scraper on demand or schedule automated runs via the Apify Scheduler (e.g., hourly, twice daily, or weekly) to track newly posted inventory.

##### Can I export high-resolution photos?

Yes. The `image_url` field provides direct links to the primary product photograph hosted on high-availability content delivery networks.

##### Does the scraper capture sold items?

Yes. Listings that appear in search results but have been marked as sold or pending include `is_sold: true` or `is_pending: true`, allowing you to analyze completed sales volumes and pricing.

***

### Ethical Data Collection & Compliance

The Facebook Marketplace Scraper is developed for legitimate market analysis, competitive research, inventory monitoring, and business intelligence. Users are responsible for adhering to applicable data privacy regulations, including GDPR, CCPA, and local terms governing public web data access. We advise all users to respect fair query frequencies, avoid overwhelming remote servers, and handle seller personal information in accordance with privacy laws.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword or term to search for on Facebook Marketplace (e.g., 'vintage leather jacket', 'gaming monitor').

## `marketplaceLocation` (type: `string`):

City slug for the Marketplace search (e.g., 'chicago', 'phoenix', 'nyc', 'losangeles', 'london').

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

List of Facebook Marketplace search or category URLs to scrape.

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

Sort order applied to Marketplace listings.

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

Minimum listing price filter.

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

Maximum listing price filter (0 for no limit).

## `daysSinceListed` (type: `string`):

Age filter for listings.

## `deliveryMethod` (type: `string`):

Filter by available delivery options.

## `conditionNew` (type: `boolean`):

Include brand new items.

## `conditionUsedLikeNew` (type: `boolean`):

Include used items in like-new condition.

## `conditionUsedGood` (type: `boolean`):

Include used items in good condition.

## `conditionUsedFair` (type: `boolean`):

Include used items in fair condition.

## `exact` (type: `boolean`):

Match query terms more strictly when building search URLs.

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

Maximum number of listings to extract.

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

Apify Proxy configuration. Residential proxies are recommended for reliable scraping.

## Actor input object example

```json
{
  "searchQuery": "laptop",
  "marketplaceLocation": "chicago",
  "startUrls": [
    "https://www.facebook.com/marketplace/chicago/search/?query=laptop"
  ],
  "sortBy": "best_match",
  "minPrice": 0,
  "maxPrice": 0,
  "daysSinceListed": "0",
  "deliveryMethod": "all",
  "conditionNew": false,
  "conditionUsedLikeNew": false,
  "conditionUsedGood": false,
  "conditionUsedFair": false,
  "exact": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "searchQuery": "laptop",
    "marketplaceLocation": "chicago",
    "startUrls": [
        "https://www.facebook.com/marketplace/chicago/search/?query=laptop"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("karamelo/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 = {
    "searchQuery": "laptop",
    "marketplaceLocation": "chicago",
    "startUrls": ["https://www.facebook.com/marketplace/chicago/search/?query=laptop"],
}

# Run the Actor and wait for it to finish
run = client.actor("karamelo/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 '{
  "searchQuery": "laptop",
  "marketplaceLocation": "chicago",
  "startUrls": [
    "https://www.facebook.com/marketplace/chicago/search/?query=laptop"
  ]
}' |
apify call karamelo/facebook-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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