~ / endpoints / Marketplace API

Facebook Marketplace Scraper API

Our Facebook Marketplace scraper targets a public item listing and returns structured JSON: the title, price and currency, location, description, images, seller, and condition. It reads the listing entity and og:product tags in the item page. Facebook requires a session for essentially all Marketplace item detail, so the endpoint is honest about when a listing renders and when it does not.

Get a free API key All Facebook endpoints

1,000

free requests / mo

2.6s

median response

JSON

structured output

residential exit

the friction

Getting Facebook Marketplace data is harder than it looks

Facebook Marketplace requires a session for essentially all item detail: logged out, an item URL returns a bare app shell with no listing data, and there is no official API that exposes Marketplace listings at all. So a populated listing generally needs an authenticated session, not a plain request.

start here

Hit the Facebook Marketplace Scraper API with one request

cURL

curl "https://api.facebookscraperapi.com/api/v1/facebook/marketplace?url=https://www.facebook.com/marketplace/item/1234567890&api_key=$API_KEY"

Python

import requests

BASE = "https://api.facebookscraperapi.com"
API_KEY = "YOUR_API_KEY"

# Pass a Marketplace item URL or id. Response follows the documented listing shape.
data = requests.get(
    f"{BASE}/api/v1/facebook/marketplace",
    params={
        "url": "https://www.facebook.com/marketplace/item/1234567890",
        "api_key": API_KEY,
    },
    timeout=30,
).json()

print(data["title"], "-", data["price"], data["currency"])
print("location:", data["location"])
print("condition:", data["condition"])

options

Parameters

Parameter	Required	Default	Notes
`url`	optional	-	A full facebook.com/marketplace/item/ URL. Required unless you pass id.
`id`	optional	-	The Marketplace item id (the numeric segment after /marketplace/item/). One of url or id is required.
`country`	optional	-	Optional two-letter country code to fetch the listing as seen from that region.
`api_key`	required	-	Your API key, passed as a query parameter. Get one free at signup.

the output

The Facebook Marketplace Scraper API output schema

200 OK

{
  "id": "1234567890",
  "url": "https://www.facebook.com/marketplace/item/1234567890/",
  "title": "Mid-century oak dining table",
  "price": 240,
  "currency": "USD",
  "description": "Solid oak dining table, seats six. Light wear on the surface, structurally solid.",
  "location": "Austin, TX",
  "condition": "Used - Good",
  "seller": "Jordan M.",
  "images": [
    "https://scontent.xx.fbcdn.net/v/t45.5328-4/example_listing_1.jpg",
    "https://scontent.xx.fbcdn.net/v/t45.5328-4/example_listing_2.jpg"
  ],
  "thumbnail": "https://scontent.xx.fbcdn.net/v/t45.5328-4/example_listing_1.jpg",
  "source": "facebook",
  "data_source": "relay-entity"
}

Field	Type	Description
`id`	string	The Marketplace item id from the URL.
`url`	string	The canonical item URL.
`title`	string	The listing title from the listing entity, product JSON-LD, or og:title.
`price`	integer	The listing price as a number, parsed from the listing price object or product offer.
`currency`	string	The price currency, defaulting to USD when not otherwise specified.
`description`	string	The listing description from the entity, product JSON-LD, or og:description.
`location`	string	The listing location text when the entity exposes it.
`condition`	string	The item condition when present, e.g. Used - Good.
`seller`	string	The seller name when the listing entity exposes it.
`images`	array	Listing photo URLs, the primary plus any additional photos, de-duplicated.
`data_source`	string	relay-entity, json-ld, or opengraph, showing where the listing fields were read from.

real uses

Build with Facebook data

Price research

When a listing renders, capture price, currency, and condition to benchmark what comparable items sell for in a location.

Listing archives

Store title, price, description, and images to keep a dated record of listings you track, including ones that later sell.

Inventory monitoring

Watch specific item URLs to see when price or condition details change on a listing.

Image collection

Pull the listing photo URLs to display or archive item images alongside your own data.

Location and condition analysis

Use the location and condition fields to segment listings by market and item quality across a set you follow.

Session-based pipelines

Because item detail is login-gated logged-out, teams running this with an authenticated session use it to keep listing data current in their own systems.

why it holds up

Why teams ship on our Facebook Marketplace Scraper API

We force the request onto a US residential exit and parse the title, price, location, condition, seller, and images from the listing entity and og:product tags. Marketplace item detail is login-gated logged-out, so when only a bare shell or the wall is served the endpoint reports a clear diagnostic instead of a fabricated listing, and it rejects id-only shells so you never get a false row.

URL or id input

Pass a full item URL or just the numeric id, and we resolve it server side.

Documented listing shape

Title, price, currency, location, description, condition, seller, and images return in a stable shape when the listing renders.

Price parsing

The price is parsed into a plain number from the listing price object or product offer, with the currency alongside it.

Residential routing built in

Requests run through US residential proxies, the best chance of a real item document if a session or relaxed gate allows it.

Shell and wall rejection

An item id alone does not prove the page rendered. We reject the bare shell and the login wall, returning a diagnostic rather than a false listing.

Data-source flag

The data_source field shows whether fields came from the listing entity, product JSON-LD, or og tags, so you can gate on quality.

vs diy

How the Facebook Marketplace Scraper API compares

	Our API	DIY (requests / headless)	Official API
Read a listing item	When it renders, else honest diagnostic	Usually a bare CSR shell	No Marketplace API exists
Setup	API key only	Residential proxies, headless browser, parsers	Not available
Price and condition	Returned when the listing renders	You parse it yourself	Not exposed
Anti-bot and proxies	Built in, US residential	You build and maintain it	Not applicable
Logged-out reality	Rejects shell and wall honestly	Shell with no clear signal	Not applicable
Output	Flat, validated JSON	Whatever you parse	Not applicable

plans & pricing

Pricing built for scale

Plan	Price	Best for
Free	1,000 requests	Testing and small jobs
Pro	$0.60 / 1k	Production workloads
Pay-as-you-go	$0.90 / 1k	Spiky or one-off volume

Median response 2.6s. You only pay for successful requests.

FAQ

What is a Facebook Marketplace scraper?

A Facebook Marketplace scraper reads a public item listing and returns it in a structured format. Our Facebook Marketplace scraper API takes an item URL or id and, when the listing renders, returns the title, price, currency, location, description, images, seller, and condition as JSON. The extractor reads the listing entity, product JSON-LD, and og:product tags.

Can I scrape Marketplace listings without logging in?

Usually not, and the endpoint is honest about it. Facebook requires a session for essentially all Marketplace item detail, so a logged-out item URL returns a bare app shell with no listing data. When that happens, the endpoint returns a clear diagnostic and rejects the shell rather than emitting a false row. For populated listing data, run the endpoint with an authenticated session.

What does the Marketplace endpoint return when it succeeds?

When an item page renders, you get the item id, canonical URL, title, price as a number, currency, description, location, condition, seller name, and an array of listing photo URLs, plus a data_source flag showing whether the fields came from the listing entity, product JSON-LD, or og tags. Fields that the page does not expose come back null.

Why does the endpoint reject some item pages?

An item id parsed from the /marketplace/item/ URL does not prove the page actually rendered any data, because logged-out item pages return a bare shell titled Facebook. To avoid false positives, the endpoint requires real listing signal, a listing entity, product data, or an og:product block, and rejects both the wall and the id-only shell with a classifiable diagnostic.

Is there an official Facebook Marketplace API?

No. Facebook does not offer a public API that exposes Marketplace listings, which is why there is no official-API column of note for this data. This endpoint reads the public item page when it renders and reports honestly when the login gate blocks it. You authenticate with a single facebookscraperapi key, and the free tier includes 1,000 requests.

How should I use this endpoint given the login gate?

Treat it as a listing endpoint that returns the documented shape when an item renders and reports a classifiable diagnostic when Facebook walls or shells the page logged-out. Teams that need consistent listing data run it with an authenticated session, and use the honest failure signal to detect and retry blocked captures instead of accepting empty rows.

Ship with the Facebook Marketplace Scraper API

Test free with 1,000 requests. No credit card needed.

Get a free API key All Facebook endpoints