# Facebook Marketplace Scraper - No Login, Local Listings (`renzomacar/facebook-marketplace-scraper`) Actor

Scrape Facebook Marketplace listings with no login required — get title, price, location, images, seller and URL for any city or search term. No account, no cookies, no API key. Ideal for resellers, dealerships, price research and local lead generation. Pay only for the listings you pull.

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

## Pricing

from $8.00 / 1,000 listings

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

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 Scraper — Local Listings & Prices, No Login

Scrape **Facebook Marketplace** local listings by **area** — no Facebook account, no cookies, no login required. Get titles, prices, locations, images, conditions and direct listing URLs as clean structured data.

Most Marketplace scrapers break because Facebook hides everything behind a login wall and aggressively rate-limits datacenter IPs. This actor uses a **real Chromium browser + residential proxies** (routed through the requested US state) and reads Marketplace's own public local feed the same way your browser does — so it keeps working without an account.

> **How location works:** Facebook geolocates the public feed to your IP. This actor routes residential proxies through the **US state** matching your `location`, so listings come back local to that area. It then reloads the feed across fresh sessions to accumulate more unique listings.

> **About keyword search:** Facebook gates true keyword *search* behind login. This actor reads the public **local feed** (no login), so the optional `searchQuery` is a best-effort client-side title filter — for full, reliable results, leave it empty.

### What you get per listing

| Field | Example |
|-------|---------|
| `title` | `2013 Chevrolet Cruze · 1LT Sedan 4D` |
| `price` / `priceAmount` | `$1,950` / `1950` |
| `condition` | `Used` |
| `location` / `city` / `state` | `Oakland, California` / `Oakland` / `CA` |
| `details` | `88K miles` |
| `imageUrl` | `https://scontent.xx.fbcdn.net/...jpg` |
| `listingUrl` | `https://www.facebook.com/marketplace/item/2801263570237384/` |
| `deliveryTypes` | `["IN_PERSON"]` |
| `createdAt` | `2026-05-27T22:44:47.000Z` |
| `isSold` / `isPending` | `false` / `false` |
| `categoryId`, `currency`, `sellerName` | … |

### Input

```json
{
  "location": "Miami",
  "maxResults": 50,
  "minPrice": 100,
  "maxPrice": 800,
  "proxyCountry": "US"
}
````

- **location** — a US city (`Miami`), `City, ST`, a US state, or exact `lat,lng`. Routes the proxy through the matching US state so listings are local.
- **maxResults** — cap on listings returned (1–500).
- **searchQuery** — *optional* best-effort title filter. Leave empty for full results (see note above).
- **minPrice / maxPrice** — optional price filters.
- **proxyCountry** — residential proxy country (`US`, `GB`, `CA`, `AU`, …). **Residential proxies are required** — Facebook rate-limits datacenter IPs.

### Output (sample)

```json
{
  "listingId": "2801263570237384",
  "title": "2013 Chevrolet Cruze · 1LT Sedan 4D",
  "price": "$1,950",
  "priceAmount": 1950,
  "currency": "USD",
  "condition": "Used",
  "location": "Oakland, California",
  "city": "Oakland",
  "state": "CA",
  "details": "88K miles",
  "imageUrl": "https://scontent.xx.fbcdn.net/...jpg",
  "listingUrl": "https://www.facebook.com/marketplace/item/2801263570237384/",
  "deliveryTypes": ["IN_PERSON"],
  "createdAt": "2026-05-27T22:44:47.000Z",
  "isSold": false,
  "isPending": false
}
```

### Use cases

- **Resellers & flippers** — find underpriced inventory across cities and react fast.
- **Price monitoring** — track what comparable items actually sell for in a market.
- **Local lead generation** — surface sellers and inventory in a target metro.
- **Market research** — measure supply, pricing and condition mix by category and city.

### Pricing

Pay-per-event:

- **$0.005** per actor start
- **$0.008** per listing returned

A 50-listing run costs about **$0.40**. You only pay for listings actually delivered.

### Notes & limitations (read this)

- **No login, no credentials.** Uses residential proxies + a real browser to read Marketplace's public local feed.
- **Location is state-level**, not exact-city. Facebook geolocates the feed by IP and Apify residential proxies target US states (not individual cities), so results are local to the requested state/metro area.
- **Keyword search needs login** on Facebook's side, which this actor deliberately avoids. The public feed is a live local browse feed (heavy on vehicles, furniture, electronics, free items). `searchQuery` filters that feed by title — leave it empty for full results.
- **Per-load batch.** Facebook serves ~20 listings per public feed load and gates pagination; this actor reloads with fresh sessions to gather more, so very large `maxResults` may return fewer if the local feed is sparse.
- Reads Facebook's public pages only; use responsibly and within Facebook's terms and your local laws.

### FAQ

**How do I scrape Facebook Marketplace listings?**
Set `location` to a US city, `City, ST`, state, or `lat,lng`, choose `maxResults`, optionally add `minPrice`/`maxPrice`, and run the actor. It routes a residential proxy through the matching US state and returns local listings with title, price, condition, location, image, and direct listing URL — no Facebook account needed.

**Do I need an API key or to log in?**
No. There is no login, cookie, Facebook account, or API key required. The actor reads Marketplace's public local feed through a real browser and residential proxies.

**Why use this instead of an official Facebook Marketplace API?**
There is no public Facebook Marketplace API — Meta does not offer one for browsing listings, and it gates keyword search and most data behind a login wall. This actor reads the same public local feed your browser sees, so you can extract listings programmatically without an account.

**Is there a Facebook Marketplace API alternative?**
Yes — since no official API exists, this actor is the practical alternative for pulling Marketplace listings at scale, returning local prices, conditions, and listing URLs as a clean dataset with pay-per-event pricing.

**Why are results state-level and why is keyword search limited?**
Facebook geolocates the public feed by IP, and Apify residential proxies target US states rather than individual cities, so listings come back local to the state/metro. True keyword search is gated behind login, which the actor avoids — so `searchQuery` is a best-effort client-side title filter; leave it empty for full results.

**Is scraping Facebook Marketplace legal?**
The actor reads only Facebook's public pages — no login or personal data. Public-data scraping is generally permitted, but you are responsible for using the data within Facebook's terms and your local laws.

### Automate it

Add this actor to an Apify **Schedule** for recurring runs — for example a daily sweep of a target metro and price band to surface freshly listed, underpriced inventory before other resellers. Pipe results into **Make, n8n, Zapier, Google Sheets, Slack, or a webhook/CRM** via Apify integrations so new local listings reach you the moment they appear. Recurring monitoring is what turns a one-off browse into a live local-deal feed.

### Related actors

- [Facebook Ad Library Scraper](https://apify.com/renzomacar/facebook-ads-library-scraper) — Spy on any brand's live Facebook & Instagram ads, also without login.
- [eBay Product Scraper](https://apify.com/renzomacar/ebay-products) — Compare local Marketplace prices against eBay sold listings for arbitrage.
- [Amazon Product Scraper](https://apify.com/renzomacar/amazon-products) — Cross-reference resale finds against current Amazon retail prices.
- [Yelp Businesses Scraper](https://apify.com/renzomacar/yelp-businesses) — Build local business and seller leads in a target metro.
- [Google Maps Businesses Scraper](https://apify.com/renzomacar/google-maps-businesses) — Generate local leads and supplier contacts in any city.

Found it useful? **[Leave a quick review →](https://apify.com/renzomacar/facebook-marketplace-scraper#reviews)**

# Actor input Schema

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

Optional keyword to keep only listings whose title contains it (e.g. 'honda', 'sofa'). NOTE: Facebook gates true keyword search behind login, so this filters the public local feed client-side — leave it EMPTY for full, reliable results.

## `location` (type: `string`):

City name (e.g. 'Miami'), a place string, or exact 'lat,lng' coordinates. This sets which local marketplace is scraped.

## `maxResults` (type: `integer`):

Maximum number of listings to return.

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

Only keep listings priced at or above this amount (optional).

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

Only keep listings priced at or below this amount (optional).

## `radiusKm` (type: `integer`):

Radius around the location to search, in kilometers.

## `proxyCountry` (type: `string`):

Two-letter country code for the residential proxy (e.g. US, GB, CA, AU). Residential IPs are REQUIRED — Facebook rate-limits datacenter IPs.

## Actor input object example

```json
{
  "location": "Miami",
  "maxResults": 50,
  "radiusKm": 65,
  "proxyCountry": "US"
}
```

# 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 = {
    "location": "Miami"
};

// Run the Actor and wait for it to finish
const run = await client.actor("renzomacar/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 = { "location": "Miami" }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Marketplace Scraper - No Login, Local Listings",
        "description": "Scrape Facebook Marketplace listings with no login required — get title, price, location, images, seller and URL for any city or search term. No account, no cookies, no API key. Ideal for resellers, dealerships, price research and local lead generation. Pay only for the listings you pull.",
        "version": "0.1",
        "x-build-id": "EPXcKa27RLJyzlKMc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/renzomacar~facebook-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-renzomacar-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/renzomacar~facebook-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-renzomacar-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/renzomacar~facebook-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-renzomacar-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": [
                    "location"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Keyword filter (optional, best-effort)",
                        "type": "string",
                        "description": "Optional keyword to keep only listings whose title contains it (e.g. 'honda', 'sofa'). NOTE: Facebook gates true keyword search behind login, so this filters the public local feed client-side — leave it EMPTY for full, reliable results."
                    },
                    "location": {
                        "title": "Location (city)",
                        "type": "string",
                        "description": "City name (e.g. 'Miami'), a place string, or exact 'lat,lng' coordinates. This sets which local marketplace is scraped."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of listings to return.",
                        "default": 50
                    },
                    "minPrice": {
                        "title": "Min price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep listings priced at or above this amount (optional)."
                    },
                    "maxPrice": {
                        "title": "Max price",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only keep listings priced at or below this amount (optional)."
                    },
                    "radiusKm": {
                        "title": "Search radius (km)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Radius around the location to search, in kilometers.",
                        "default": 65
                    },
                    "proxyCountry": {
                        "title": "Residential proxy country",
                        "type": "string",
                        "description": "Two-letter country code for the residential proxy (e.g. US, GB, CA, AU). Residential IPs are REQUIRED — Facebook rate-limits datacenter IPs.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
