Facebook Marketplace Listings Scraper

Extract anonymous public Facebook Marketplace listings from supplied city, category, or search URLs into a structured Apify dataset.

Use the Actor to build repeatable resale inventory and asking-price snapshots without a Facebook login. Each accepted row includes a stable listing ID, title, displayed price, location, image, available condition/category signals, and canonical listing URL.

The Actor only reads cards Facebook exposes publicly. It does not log in, contact sellers, scrape private content, or promise seller contact details.

What can you do with Facebook Marketplace Listings Scraper?

• Collect local resale inventory for a one-time market analysis.
• Schedule recurring runs and compare listing IDs or prices downstream.
• Combine several city or query URLs into one deduplicated dataset.
• Export public listing cards to CSV, Excel, JSON, a database, or a data pipeline.
• Track category supply without manually copying search results.

The Actor preserves the filters encoded in each supplied Marketplace URL. It stops at maxItems accepted unique listings or the available result-charge budget, whichever comes first.

Who is this Actor for?

Resale operators can review local asking prices and available inventory.

Marketplace analysts can create comparable snapshots across cities or product searches.

Data teams can feed normalized public listing records into dashboards and warehouses.

Developers can call the Actor from scheduled workflows instead of maintaining Facebook SSR parsing and residential proxy sessions.

This Actor is not intended for seller outreach, private-profile enrichment, messaging, or account automation.

Why use this Facebook Marketplace extractor?

Facebook's anonymous Marketplace page delivery varies by network identity. A normal server request often reaches a login shell instead of listings.

This Actor uses bounded US residential HTTP sessions and parses structured data embedded in the public server-rendered response. It avoids browser rendering and media downloads, keeping the workflow smaller and more predictable.

The extraction route:

1. validates every URL before any request;
2. requests the public Marketplace page through a US residential session;
3. rejects login, challenge, and unrecognized response shapes;
4. rotates the session up to a bounded retry limit;
5. normalizes and deduplicates recognized listing cards;
6. charges only rows written to the dataset.

What Facebook Marketplace data is extracted?

Field	Type	Meaning
listingId	string	Stable Facebook Marketplace listing identifier
title	string	Public listing title
price	string or null	Price exactly as displayed
priceAmount	number or null	Finite source numeric amount or canonical numeric string, including genuine zero
currency	string or null	Valid explicit source currency, otherwise a recognized display marker
location	string or null	Public display location
city	string or null	Public city signal
state	string or null	Public state/region signal
imageUrl	string or null	Primary public listing image URL
condition	string or null	Condition when present in the public card
categoryId	string or null	Facebook category identifier when present
isSold	boolean	Public sold-state signal
deliveryTypes	string[]	Public delivery options in the card
listingUrl	string	Canonical Marketplace item URL
sourceUrl	string	Marketplace URL that produced the row
scrapedAt	string	UTC extraction timestamp

Nullable fields remain null when Facebook does not include them. The Actor does not guess missing amounts or conditions. Repeated representations of a card fill missing fields without erasing existing values; the first present conflicting value wins.

Currency prefers a valid explicit source ISO code, then US$, C$/CA$, A$/AU$, €, or £. A bare $ keeps the existing USD fallback for the US residential route; unknown prefixed dollar markers are not assumed to be USD. The displayed price is preserved unchanged. Blank, malformed, or non-finite amounts are null, not zero.

How to scrape Facebook Marketplace listings

1. Open the Actor input page in Apify Console.
2. Add one or more public facebook.com/marketplace/... URLs.
3. Keep maxItems small for an initial run.
4. Click Start.
5. Open the default dataset when the run succeeds.
6. Export the overview as JSON, CSV, Excel, XML, or RSS.
7. For monitoring, schedule the same input and compare listingId, priceAmount, or isSold in your destination.

A useful first input is:

{
  "startUrls": [
    {
      "url": "https://www.facebook.com/marketplace/nyc/search?query=bicycle"
    }
  ],
  "maxItems": 10
}

Input parameters

startUrls

Required array of one to 20 public Facebook Marketplace URLs.

Supported forms include city roots, category paths, and search URLs under /marketplace/. Query parameters and filters already encoded in the URL are preserved.

Examples:

https://www.facebook.com/marketplace/nyc/search?query=bicycle
https://www.facebook.com/marketplace/seattle/search?query=furniture
https://www.facebook.com/marketplace/losangeles/search?query=used%20car

String URLs and objects with a url property are supported. HTTP URLs upgrade to HTTPS, Facebook subdomains normalize to www.facebook.com, and fragments are removed. Identical normalized URLs are requested once, in first-occurrence order; distinct query filters remain separate.

Non-Facebook domains, paths outside /marketplace/, non-HTTP(S) schemes, credentialed URLs, nonstandard ports, and malformed entries fail validation before startup charging or proxy use. Login credentials are neither accepted nor required.

maxItems

Optional integer from 1 to 500. The default is 50.

This is a run-wide cap across all supplied URLs, after deduplication. It is not a promise that Facebook will expose that many public cards.

Output example

A current normalized dataset row has this shape:

{
  "listingId": "123456789012345",
  "title": "Road bicycle",
  "price": "$180",
  "priceAmount": 180,
  "currency": "USD",
  "location": "New York, New York",
  "city": "New York",
  "state": "New York",
  "imageUrl": "https://scontent.example.fbcdn.net/example.jpg",
  "condition": null,
  "categoryId": "807311116002614",
  "isSold": false,
  "deliveryTypes": ["IN_PERSON"],
  "listingUrl": "https://www.facebook.com/marketplace/item/123456789012345/",
  "sourceUrl": "https://www.facebook.com/marketplace/nyc/search?query=bicycle",
  "scrapedAt": "2026-08-12T19:52:31.000Z"
}

The identifier and image above are redacted examples; actual runs return current public source values.

How much does it cost to scrape Facebook Marketplace listings?

The Actor uses pay per event pricing:

• Start: $0.005 once per run.
• Listing item: tiered by Apify plan; BRONZE is currently $0.0032 per accepted dataset row.

At the BRONZE tier, 10 accepted listings cost about $0.037, 100 cost about $0.325, and 500 cost about $1.605. The start fee is included in these examples.

Only accepted unique listing rows trigger the item event. Retries, rejected payloads, duplicates, and missing optional fields do not create extra item charges.

Your Apify plan determines the active tier. Check the pricing panel for the exact tiered event rate before a large run. Apify's maximum total charge setting (maxTotalChargeUsd) is also respected: if the remaining budget cannot cover another item, the run stops normally before writing that row or requesting another source. A budget smaller than the start fee stops before charging or scraping.

Persistence uses the SDK's write-then-charge ordering, not an atomic billing transaction. An unexpected billing or storage error fails the run and may leave a partial dataset; inspect the coverage summary and failed status before importing it.

Monitoring and integration workflows

Scheduled inventory snapshots

Schedule a city/query input daily or weekly. Store each run's dataset and compare stable listingId values to identify newly exposed or removed cards.

Asking-price analysis

Load priceAmount, currency, city, and categoryId into a spreadsheet or warehouse. Keep price as the source display value for auditability.

Multi-city comparison

Supply several URLs in one run. The Actor writes a single deduplicated dataset and retains sourceUrl so rows can be grouped by search.

Webhooks and downstream automation

Use an Apify webhook after ACTOR.RUN.SUCCEEDED to trigger a Make, Zapier, n8n, or custom ingestion workflow.

Run with the Apify API

Replace YOUR_TOKEN with an Apify API token.

cURL

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~facebook-marketplace-public-listings-scraper/runs?token=YOUR_TOKEN&waitForFinish=300" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.facebook.com/marketplace/nyc/search?query=bicycle"}],"maxItems":10}'

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/facebook-marketplace-public-listings-scraper').call({
    startUrls: [{ url: 'https://www.facebook.com/marketplace/nyc/search?query=bicycle' }],
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Python

from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("automation-lab/facebook-marketplace-public-listings-scraper").call(
    run_input={
        "startUrls": [{"url": "https://www.facebook.com/marketplace/nyc/search?query=bicycle"}],
        "maxItems": 10,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)

Use with MCP and AI agents

Claude Code setup

Add the Actor to Claude Code through Apify MCP:

claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/facebook-marketplace-public-listings-scraper"

Claude Desktop, Cursor, and VS Code setup

Claude Desktop, Cursor, and VS Code clients can use the equivalent HTTP MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/facebook-marketplace-public-listings-scraper"
    }
  }
}

Example prompts:

• “Run the Facebook Marketplace listings scraper for this NYC bicycle search and return a price summary.”
• “Collect these Seattle and Los Angeles Marketplace searches, then group records by source URL.”
• “Schedule this input weekly and compare listing IDs with the previous dataset.”

Reliability, retries, and limits

Facebook can change anonymous page delivery and embedded data structures without notice.

The Actor rotates residential sessions after transient HTTP/network, login, challenge, or empty-shape failures, up to three attempts per source. Identity-dependent 400 responses on validated Marketplace URLs retain bounded fresh-session recovery; permanent HTTP errors such as 404 fail without repeated requests. Each request is capped at 60 seconds and the remaining execution budget, with a 15-second shutdown reserve. Recovery never starts another request without remaining work time.

An inaccessible source or exhausted execution window fails the run rather than returning a misleading empty or complete snapshot. Previously saved rows remain available as partial output. Result-cap and charge-budget stops are normal successful limited snapshots, not exhaustive coverage.

Current scope is the listing cards included in the initial public server-rendered page. The Actor does not promise exhaustive GraphQL pagination, listing detail descriptions, seller profiles, seller contact information, or historical changes.

maxItems is capped at 500. Public inventory may be sparse or differ by geography and time.

Run coverage summary

Open Run coverage summary in the output tab, or the default key-value store's RUN-SUMMARY JSON record. It is updated at safe checkpoints and completion/failure and contains:

• supplied and unique URL counts; attempted and successful source counts;
• upstream attempts, recognized merged cards, saved rows, and cross-source duplicate listings;
• status (running, succeeded, or failed) and stopReason (maxItems, budget, deadline, failure, or null);
• at most 20 normalized source URLs with retrieval status, attempt count, and diagnostic reason, including unvisited sources.

A source marked succeeded was retrieved and parsed; its rows may still be limited by a cap, budget, or persistence failure. recognized counts merged cards from fetched sources before cross-source deduplication or caps. The summary contains no response HTML, cookies, or proxy credentials. A platform kill can leave its last checkpoint marked running; the terminal run status is authoritative. Invalid input fails before creating the summary.

Troubleshooting

Why did the run fail with a login or public-listing error?

Retry once later with the same valid public Marketplace URL. Facebook may temporarily serve a login/challenge response to all bounded sessions. Do not add credentials; this Actor is anonymous by design.

Why are there fewer records than maxItems?

maxItems is a ceiling. Facebook may expose fewer cards in its initial public SSR response, and duplicates across supplied URLs count once.

Why is a field null?

Facebook does not include every field on every public listing card. The Actor preserves missing values as null instead of inferring them.

Why was my URL rejected?

Use an HTTPS Facebook URL whose path begins with /marketplace/. Profile, group, login, short-link, and third-party URLs are intentionally unsupported.

Responsible use and legality

Scrape only public information you are authorized to collect and use.

You are responsible for complying with Facebook's terms, applicable privacy and database laws, intellectual-property rights, and local regulations. Avoid attempts to identify private individuals, build sensitive profiles, contact sellers without a lawful basis, or circumvent access controls.

The Actor does not bypass login, access private content, or accept user credentials. Remove or minimize personal data in downstream systems when it is not needed for your legitimate purpose.

Data handling, dependencies, and support

This Actor uses no AI or model provider. Public listing cards are processed by HTTP and structured JSON parsing only. It collects public item IDs, titles, prices, locations, image links, and listing signals, not seller contacts or private profiles. User input URLs appear in run storage and the coverage summary; do not place secrets or personal identifiers in URL filters.

Apify hosts execution, datasets, key-value storage, logs, and the US residential proxy route. Proxy, compute, and storage operating costs are publisher-owned and included in the documented event pricing; no external account or surprise service fee is required. Facebook receives the anonymous requests and determines available public content. No media files are downloaded, and raw responses/cookies are not saved.

Failed operations send sanitized diagnostic input, exceptions, and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL query strings are removed; diagnostic reports are retained for 30 days. Normal retries and successful recovery are not reported as fatal errors.

There is no cross-run cache or Actor-controlled archive. Processing and session state are ephemeral; datasets, input, coverage, and logs follow your Apify account's configured storage retention. Delete the run and its dataset/key-value stores through Apify Console or API when no longer needed. Exported copies are your responsibility. Refer to Apify's privacy policy and data retention documentation for platform handling.

For a problem, open an issue on this Actor's Apify Store Issues tab with the run link and sanitized input. Do not include credentials. The Actor uses Apify's standard terms and is an independent Automation Lab product, not affiliated with or endorsed by Facebook or Meta.

Related Automation Lab Actors

• OfferUp Marketplace Listings Scraper for public US OfferUp inventory.
• Wallapop Marketplace Scraper for public Spanish resale listings.
• Facebook Page Recommendations Scraper for public Page recommendation records rather than Marketplace inventory.

These Actors are separate products and do not combine datasets automatically.

FAQ

Does it require a Facebook account?

No. The Actor retrieves only listing cards Facebook exposes to anonymous public US residential sessions.

Can it scrape seller phone numbers or send messages?

No. Seller contact and messaging are outside the product scope.

Can I monitor new and changed listings?

Yes, by scheduling recurring runs and comparing datasets downstream. The Actor emits stable IDs and timestamps; it does not maintain a built-in history or send change alerts.

Does it download listing images?

No. It returns the public primary image URL when present, which reduces transfer and runtime.

Can I scrape several cities in one run?

Yes. Add up to 20 Marketplace URLs. Results are deduplicated by listing ID and retain their source URL.

Is every Facebook Marketplace listing included?

No. Results are limited to the public cards Facebook includes in the server-rendered response at run time.

Can I use the dataset in Excel or Google Sheets?

Yes. Export the default dataset as CSV or Excel, or connect it to your preferred integration.

What happens when Facebook blocks all attempts?

The run fails non-zero with a clear message after bounded session recovery. This prevents an access failure from being mistaken for a legitimate empty market.