# Facebook Marketplace Scraper - Any Category & City (`swerve/facebook-marketplace-scraper`) Actor

Scrape Facebook Marketplace for any category (electronics, vehicles, furniture, property, and more) or by keyword, no login. Pick a category and cities or whole countries from dropdowns (USA, UK, Canada, Australia, Europe, Mexico, Brazil). Returns id, title, price, currency, location, and image.

- **URL**: https://apify.com/swerve/facebook-marketplace-scraper.md
- **Developed by:** [Swerve](https://apify.com/swerve) (community)
- **Categories:** E-commerce, Social media
- **Stats:** 3 total users, 2 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 - Any Category & City

Scrape **Facebook Marketplace** listings for **any product category** (electronics, vehicles, furniture, property, and more) or **search by keyword** like "iPhone 15", **with no login**. Pick a category and the cities or whole countries you want from dropdowns. Returns the listing id, title, price, currency, location, full description, and image for each listing.

### What you get per listing

| Field | Description |
| --- | --- |
| `id` | Facebook Marketplace listing id |
| `url` | Direct link: `https://www.facebook.com/marketplace/item/<id>` |
| `title` | Listing title |
| `price` | Price as a number (no symbol), e.g. `450`. `null` for "Free"/no-price listings. See `currency`. |
| `currency` | ISO currency: `USD`, `GBP`, `EUR`, `CAD`, `AUD`, `MXN`, `BRL`, or `ILS` |
| `location` | City/area name from the listing, e.g. `Brooklyn`, `Manchester` |
| `description` | Full listing description (from the detail page) |
| `image` | Listing image URL |
| `category` | The browse category label (e.g. `Electronics`) or `Keyword search` |
| `searchQuery` | The keyword searched, or empty when browsing a category |

### Input

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| `category` | select | `Electronics` | The Marketplace category to browse. Ignored when a keyword is set. |
| `searchQuery` | string | `iPhone` | Optional keyword. When set, searches **all** categories and overrides `category`. |
| `cities` | multi-select | `New York, USA` | Pick specific cities (type to filter). |
| `countries` | multi-select | — | Pick whole countries to sweep all their listed major cities. Merged with `cities`. |
| `radiusKm` | integer | `12` | Search radius around each city center, in km. |
| `maxPerCoord` | integer | `40` | Cards collected per city. Facebook serves at most ~24 per search point to logged-out users. |
| `matchCityOnly` | boolean | `false` | Off by default: you get the whole metro (a New York search includes Brooklyn, Yonkers, Jersey City). Turn on to keep only the exact city name. |
| `cityCoveragePoints` | integer | `5` | Search points swept per city (more = more coverage, proportional cost). |
| `fetchDetails` | boolean | `true` | Open each listing for the full description. Slower; turn off for card-level data only. |
| `extraCoords` | array (advanced) | — | Search arbitrary points: `{ label, lat, lng, radiusKm, countryCode, currency }`. |
| `proxyConfiguration` | proxy | Apify RESIDENTIAL | The actor automatically rides a proxy in each city's own country. |

Just click **Run** — the prefill searches **iPhone in New York**. Clear the keyword and pick a category to browse a whole category instead.

#### Categories

Property for rent, Property for sale, Vehicles, Electronics, Clothing & apparel, Furniture, Home goods, Appliances, Garden & outdoor, Tools & home improvement, Toys & games, Sporting goods, Pet supplies, Musical instruments, Books/movies/music, Baby & kids, Hobbies, Antiques & collectibles, Entertainment, Free stuff.

#### Cities and countries

Pick specific cities from the **Cities** dropdown, or add whole countries under **Countries** to include all their listed major cities at once. Covered countries: USA, UK, Canada, Australia, Ireland, Spain, Germany, France, Italy, Portugal, Netherlands, Mexico, Brazil, and Israel. For a location not in the list, add it under **Advanced → Extra coordinates**:

```json
[{ "label": "Valencia", "lat": 39.4699, "lng": -0.3763, "radiusKm": 12, "countryCode": "ES" }]
````

`countryCode` (ISO-2) picks the proxy country and the default currency; it defaults to `US`.

### Example output

Keyword search (USD):

```json
{
  "id": "1689727542231621",
  "url": "https://www.facebook.com/marketplace/item/1689727542231621",
  "title": "iPhone 13 Pro 256GB - Unlocked",
  "price": 480,
  "currency": "USD",
  "location": "Brooklyn",
  "description": "Great condition, battery health 92%, comes with box and charger...",
  "image": "https://scontent.fsdv1-2.fna.fbcdn.net/v/t39.84726-6/...jpg",
  "category": "Keyword search",
  "searchQuery": "iPhone"
}
```

### How it works

Facebook Marketplace shows public listings to logged-out users, but only if you reach it the right way:

1. **Location by city slug (keyword + general categories).** For logged-out users the URL `latitude`/`longitude` are honored **only** on the Property categories; for keyword search and general category browse Facebook ignores the coordinate (and the proxy country) and falls back to a default location. The reliable lever is Facebook's own location **slug** in the URL path: `/marketplace/<city>/search?query=...` (keyword) and `/marketplace/<city>/<category>/` (browse) return that city's metro. The actor maps each dropdown city to its verified slug.
2. **Location by coordinate (Property only).** The two Property categories genuinely honor `latitude`/`longitude`, so they are swept as a small grid of coordinate points across the city for wider coverage.
3. **Per-country proxy + language.** Selected cities are grouped by country, and each group is crawled over an Apify RESIDENTIAL proxy in that country with the matching `Accept-Language` header. This reduces anti-bot friction and returns the right locale.
4. **No infinite scroll.** Logged-out infinite scroll does **not** load more listings, so each city returns roughly 24-40 cards per search. Coverage comes from selecting more cities, not from scrolling.
5. **No-login detail enrichment.** The full description lives in the listing detail page's meta tags and embedded JSON, present even though a login prompt overlays the content.
6. **Currency by country.** For dropdown cities the currency (USD, GBP, EUR, CAD, AUD, MXN, BRL, ILS) is taken from the city's own country, so a bare `$` in Canada is read as CAD, not USD.

Every city in the dropdown has a verified Facebook location, so keyword and general-category searches target the chosen city (and its metro) accurately.

Each listing is deduped by id within the run.

### Limits and notes

- **~24-40 listings per city.** A Facebook limit for logged-out users, not an actor cap. Add more cities to get more.
- **Some listings have no description.** A minority ship an empty description; the card-level data (price, currency, location, title, image) is always kept.
- **Residential proxy required.** Datacenter IPs get a login wall. The actor uses Apify RESIDENTIAL proxy and picks each city's country automatically (the prefilled default).

### Use cases

- Price research and resale/arbitrage sourcing across a category or a specific product.
- Lead generation and market monitoring (property, vehicles, and more), in one country or across many.
- Tracking new supply per city over time, side by side across markets.

# Actor input Schema

## `category` (type: `string`):

Which Facebook Marketplace category to browse. Ignored if you type a keyword below (a keyword searches across all categories). Example: Electronics.

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

Search a specific product across ALL categories. When set, this overrides the Category dropdown above. Example: iPhone 15 Pro, PS5, road bike, IKEA sofa. Leave empty to browse the whole category you picked.

## `cities` (type: `array`):

Pick one or more cities to search (type to filter the list). Each city is swept with a small grid of points (see 'Coverage points per city') to get past Facebook's ~24-per-search limit for logged-out users. Add whole countries below to include all their major cities at once. Example: New York, USA + London, UK.

## `countries` (type: `array`):

Pick one or more countries (type to filter) to search ALL of that country's listed major cities at once. Combine with specific cities above; duplicates are merged. Example: United States + United Kingdom.

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

How far around each city center to search, in kilometers. Larger values pull in nearby suburbs. Example: 12 (default) covers a city and its inner ring; use 20-25 to include the wider metro.

## `maxPerCoord` (type: `integer`):

Stop collecting cards from a single city after this many. Facebook serves at most ~24 to logged-out users per search point, so coverage comes from more points/cities. Example: 40. No upper cap.

## `matchCityOnly` (type: `boolean`):

Off by default. Each search returns the whole metro area around your city, so Facebook includes nearby suburbs (a New York search also returns Brooklyn, Yonkers, Jersey City). Turn this ON to keep only listings whose own city name matches your selection exactly (this drops the surrounding suburbs).

## `cityCoveragePoints` (type: `integer`):

Only used for the two Property categories, which are searched by coordinate: it sweeps several points across the city to get past Facebook's ~24-per-search limit. Keyword search and all other categories are searched by city and ignore this (they return the city's listings in one request). Example: 5.

## `fetchDetails` (type: `boolean`):

When on, opens each listing's detail page to read the FULL description, title, and image. Turning it off is much faster but returns only card-level data (price, city, short title, thumbnail) and an empty description. Example: leave on.

## `extraCoords` (type: `array`):

Search arbitrary points not in the city dropdown. Each entry is { label, lat, lng, radiusKm, countryCode, currency }. lat/lng set the Marketplace location; countryCode (ISO-2, e.g. 'US', 'ES', 'AU') picks the proxy country and currency. Example: { "label": "Valencia", "lat": 39.4699, "lng": -0.3763, "radiusKm": 12, "countryCode": "ES" }. countryCode defaults to US.

## `knownDetailIds` (type: `array`):

Listing ids you already have full details for (from a previous run). The actor ships these as cheap card-level rows and SKIPS their detail page; only new ids get the (expensive) detail enrichment. Use this on re-scans to cut cost. Leave empty to enrich every listing. Example: \["1007384061689614", "1088244741046904"].

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

Facebook serves a login wall to datacenter IPs and ignores non-local IPs for location. The actor uses Apify RESIDENTIAL proxy and automatically picks each city's country (US for US cities, UK for UK cities, etc.). Leave this as the default unless you have a reason to pin a single proxy country.

## Actor input object example

```json
{
  "category": "electronics",
  "searchQuery": "iPhone",
  "cities": [
    "new-york"
  ],
  "radiusKm": 12,
  "maxPerCoord": 40,
  "matchCityOnly": false,
  "cityCoveragePoints": 5,
  "fetchDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "iPhone",
    "cities": [
        "new-york"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("swerve/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": "iPhone",
    "cities": ["new-york"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("swerve/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 '{
  "searchQuery": "iPhone",
  "cities": [
    "new-york"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call swerve/facebook-marketplace-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Facebook Marketplace Scraper - Any Category & City",
        "description": "Scrape Facebook Marketplace for any category (electronics, vehicles, furniture, property, and more) or by keyword, no login. Pick a category and cities or whole countries from dropdowns (USA, UK, Canada, Australia, Europe, Mexico, Brazil). Returns id, title, price, currency, location, and image.",
        "version": "1.0",
        "x-build-id": "LstwXUYefIRqtYXr2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/swerve~facebook-marketplace-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-swerve-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/swerve~facebook-marketplace-scraper/runs": {
            "post": {
                "operationId": "runs-sync-swerve-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/swerve~facebook-marketplace-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-swerve-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",
                "properties": {
                    "category": {
                        "title": "Category",
                        "enum": [
                            "propertyrentals",
                            "propertyforsale",
                            "vehicles",
                            "electronics",
                            "apparel",
                            "furniture",
                            "home",
                            "appliances",
                            "garden",
                            "tools",
                            "toys",
                            "sports",
                            "pets",
                            "instruments",
                            "books",
                            "family",
                            "hobbies",
                            "antiques",
                            "entertainment",
                            "free"
                        ],
                        "type": "string",
                        "description": "Which Facebook Marketplace category to browse. Ignored if you type a keyword below (a keyword searches across all categories). Example: Electronics.",
                        "default": "electronics"
                    },
                    "searchQuery": {
                        "title": "Keyword (optional)",
                        "type": "string",
                        "description": "Search a specific product across ALL categories. When set, this overrides the Category dropdown above. Example: iPhone 15 Pro, PS5, road bike, IKEA sofa. Leave empty to browse the whole category you picked."
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Pick one or more cities to search (type to filter the list). Each city is swept with a small grid of points (see 'Coverage points per city') to get past Facebook's ~24-per-search limit for logged-out users. Add whole countries below to include all their major cities at once. Example: New York, USA + London, UK.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "new-york",
                                "los-angeles",
                                "chicago",
                                "houston",
                                "phoenix",
                                "philadelphia",
                                "san-antonio",
                                "san-diego",
                                "dallas",
                                "miami",
                                "atlanta",
                                "boston",
                                "seattle",
                                "denver",
                                "washington-dc",
                                "san-francisco",
                                "las-vegas",
                                "austin",
                                "london",
                                "manchester",
                                "birmingham",
                                "leeds",
                                "glasgow",
                                "liverpool",
                                "edinburgh",
                                "bristol",
                                "toronto",
                                "montreal",
                                "vancouver",
                                "calgary",
                                "ottawa",
                                "edmonton",
                                "sydney",
                                "melbourne",
                                "brisbane",
                                "perth",
                                "adelaide",
                                "dublin",
                                "madrid",
                                "barcelona",
                                "valencia",
                                "seville",
                                "malaga",
                                "berlin",
                                "munich",
                                "hamburg",
                                "frankfurt",
                                "cologne",
                                "paris",
                                "marseille",
                                "lyon",
                                "toulouse",
                                "rome",
                                "milan",
                                "naples",
                                "turin",
                                "lisbon",
                                "amsterdam",
                                "rotterdam",
                                "mexico-city",
                                "guadalajara",
                                "monterrey",
                                "sao-paulo",
                                "rio-de-janeiro",
                                "brasilia",
                                "tel-aviv",
                                "jerusalem"
                            ],
                            "enumTitles": [
                                "New York, USA",
                                "Los Angeles, USA",
                                "Chicago, USA",
                                "Houston, USA",
                                "Phoenix, USA",
                                "Philadelphia, USA",
                                "San Antonio, USA",
                                "San Diego, USA",
                                "Dallas, USA",
                                "Miami, USA",
                                "Atlanta, USA",
                                "Boston, USA",
                                "Seattle, USA",
                                "Denver, USA",
                                "Washington DC, USA",
                                "San Francisco, USA",
                                "Las Vegas, USA",
                                "Austin, USA",
                                "London, UK",
                                "Manchester, UK",
                                "Birmingham, UK",
                                "Leeds, UK",
                                "Glasgow, UK",
                                "Liverpool, UK",
                                "Edinburgh, UK",
                                "Bristol, UK",
                                "Toronto, Canada",
                                "Montreal, Canada",
                                "Vancouver, Canada",
                                "Calgary, Canada",
                                "Ottawa, Canada",
                                "Edmonton, Canada",
                                "Sydney, Australia",
                                "Melbourne, Australia",
                                "Brisbane, Australia",
                                "Perth, Australia",
                                "Adelaide, Australia",
                                "Dublin, Ireland",
                                "Madrid, Spain",
                                "Barcelona, Spain",
                                "Valencia, Spain",
                                "Seville, Spain",
                                "Malaga, Spain",
                                "Berlin, Germany",
                                "Munich, Germany",
                                "Hamburg, Germany",
                                "Frankfurt, Germany",
                                "Cologne, Germany",
                                "Paris, France",
                                "Marseille, France",
                                "Lyon, France",
                                "Toulouse, France",
                                "Rome, Italy",
                                "Milan, Italy",
                                "Naples, Italy",
                                "Turin, Italy",
                                "Lisbon, Portugal",
                                "Amsterdam, Netherlands",
                                "Rotterdam, Netherlands",
                                "Mexico City, Mexico",
                                "Guadalajara, Mexico",
                                "Monterrey, Mexico",
                                "Sao Paulo, Brazil",
                                "Rio de Janeiro, Brazil",
                                "Brasilia, Brazil",
                                "תל אביב",
                                "ירושלים"
                            ]
                        },
                        "default": [
                            "new-york"
                        ]
                    },
                    "countries": {
                        "title": "Countries (whole-country sweep)",
                        "type": "array",
                        "description": "Pick one or more countries (type to filter) to search ALL of that country's listed major cities at once. Combine with specific cities above; duplicates are merged. Example: United States + United Kingdom.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "US",
                                "GB",
                                "CA",
                                "AU",
                                "IE",
                                "ES",
                                "DE",
                                "FR",
                                "IT",
                                "PT",
                                "NL",
                                "MX",
                                "BR",
                                "IL"
                            ],
                            "enumTitles": [
                                "United States",
                                "United Kingdom",
                                "Canada",
                                "Australia",
                                "Ireland",
                                "Spain",
                                "Germany",
                                "France",
                                "Italy",
                                "Portugal",
                                "Netherlands",
                                "Mexico",
                                "Brazil",
                                "Israel"
                            ]
                        }
                    },
                    "radiusKm": {
                        "title": "Search radius per city (km)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "How far around each city center to search, in kilometers. Larger values pull in nearby suburbs. Example: 12 (default) covers a city and its inner ring; use 20-25 to include the wider metro.",
                        "default": 12
                    },
                    "maxPerCoord": {
                        "title": "Max listings per city",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop collecting cards from a single city after this many. Facebook serves at most ~24 to logged-out users per search point, so coverage comes from more points/cities. Example: 40. No upper cap.",
                        "default": 40
                    },
                    "matchCityOnly": {
                        "title": "Restrict to the exact city name",
                        "type": "boolean",
                        "description": "Off by default. Each search returns the whole metro area around your city, so Facebook includes nearby suburbs (a New York search also returns Brooklyn, Yonkers, Jersey City). Turn this ON to keep only listings whose own city name matches your selection exactly (this drops the surrounding suburbs).",
                        "default": false
                    },
                    "cityCoveragePoints": {
                        "title": "Coverage points per city (property only)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only used for the two Property categories, which are searched by coordinate: it sweeps several points across the city to get past Facebook's ~24-per-search limit. Keyword search and all other categories are searched by city and ignore this (they return the city's listings in one request). Example: 5.",
                        "default": 5
                    },
                    "fetchDetails": {
                        "title": "Fetch full description per listing (slower)",
                        "type": "boolean",
                        "description": "When on, opens each listing's detail page to read the FULL description, title, and image. Turning it off is much faster but returns only card-level data (price, city, short title, thumbnail) and an empty description. Example: leave on.",
                        "default": true
                    },
                    "extraCoords": {
                        "title": "Extra coordinates (advanced)",
                        "type": "array",
                        "description": "Search arbitrary points not in the city dropdown. Each entry is { label, lat, lng, radiusKm, countryCode, currency }. lat/lng set the Marketplace location; countryCode (ISO-2, e.g. 'US', 'ES', 'AU') picks the proxy country and currency. Example: { \"label\": \"Valencia\", \"lat\": 39.4699, \"lng\": -0.3763, \"radiusKm\": 12, \"countryCode\": \"ES\" }. countryCode defaults to US."
                    },
                    "knownDetailIds": {
                        "title": "Known listing ids (skip detail fetch)",
                        "type": "array",
                        "description": "Listing ids you already have full details for (from a previous run). The actor ships these as cheap card-level rows and SKIPS their detail page; only new ids get the (expensive) detail enrichment. Use this on re-scans to cut cost. Leave empty to enrich every listing. Example: [\"1007384061689614\", \"1088244741046904\"]."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Facebook serves a login wall to datacenter IPs and ignores non-local IPs for location. The actor uses Apify RESIDENTIAL proxy and automatically picks each city's country (US for US cities, UK for UK cities, etc.). Leave this as the default unless you have a reason to pin a single proxy country.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
