# ForSaleByOwner FSBO Listings Scraper (`parseforge/forsalebyowner-scraper`) Actor

Scrapes ForSaleByOwner.com listings in three modes: rich API data by city and state, featured homepage cards, or sitemap address-only records. Returns each property as a flat row with price, beds, baths, square footage, photos, and seller details.

- **URL**: https://apify.com/parseforge/forsalebyowner-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Real estate, Lead generation, Automation
- **Stats:** 16 total users, 2 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 1,000 fsbo listing records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### ForSaleByOwner FSBO Listings Scraper

**Scrape ForSaleByOwner FSBO listings by city, state, or from the featured homepage cards.** Each property comes with price, beds, baths, square footage, photos, and seller details. No login or API key. Export to CSV, JSON, Excel, or XML.

ForSaleByOwner.com lists homes sold directly by owners, but there is no public API and the site rotates its featured listings constantly. This Actor reads the public listing feeds in three modes: rich API data by city and state, the homepage featured cards, or a sitemap of thousands of address-only records. Every run returns a flat, consistent row per property.

| Who uses it | What they scrape ForSaleByOwner for |
|---|---|
| Real estate investors | Find off-market FSBO properties in target cities before they hit the MLS |
| Real estate agents | Build lead lists of owners selling without an agent |
| Market analysts | Track FSBO inventory and pricing trends by state |
| Homebuyers | Monitor new for-sale-by-owner listings in a specific area |

### What it does

This Actor collects ForSaleByOwner listings by city and state slug, from the featured homepage cards, or from the sitemap, and returns each property as one flat row.

- 🏙️ **Three data modes:** API mode for rich 30+ field listings by city and state, Featured mode for the ~20 homepage cards, and Sitemap mode for thousands of address-only records.
- 📍 **Location targeting:** Enter a city-state slug like los-angeles-california or miami-florida to pull every active listing in that market.
- 🗺️ **State filtering:** Limit results to one or more US states with two-letter codes, applied after fetching.
- 📊 **Flat output:** Every property is returned as a single row with consistent columns, ready for spreadsheets or databases.
- ⚡ **Scalable runs:** Set a maximum from 1 to 1,000,000 properties per run, so you control the volume.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with ForSaleByOwner data

**🏠 Build FSBO lead lists.**

A real estate agent runs the Actor in API mode for austin-texas and exports the CSV to get owner names, phone numbers, and property details for direct outreach.

**📈 Track FSBO inventory by state.**

A market analyst runs the Actor in Sitemap mode with a state filter for Florida and Texas to compare the number of for-sale-by-owner listings month over month.

**🔍 Monitor new featured listings.**

An investor schedules the Actor in Featured mode daily to catch the newest homepage listings before they are widely seen.

**💰 Find off-market deals.**

A homebuyer runs the Actor in API mode for miami-florida and filters for properties under a target price to find motivated sellers.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key needed** | Reads the public ForSaleByOwner feeds directly, so you can start scraping in minutes |
| **Rich property data** | API mode returns 30+ fields including description, photos, owner info, lot size, year built, MLS number, and features |
| **Three coverage options** | Get deep data for one market, the latest featured listings, or a broad address-only sweep |
| **Clean, flat records** | Every listing is normalized into one row, so you can export to CSV, JSON, Excel, or XML without cleanup |

### How it compares

This Actor offers three data modes and rich API fields, while the competitor focuses only on the featured homepage cards.

| Feature | ParseForge | ForSaleByOwner Featured Listings Scraper |
|---|---|---|
| Rich API data by city and state | Yes, 30+ fields per listing | Not listed |
| Featured homepage cards | Yes, up to ~20 listings | Yes |
| Sitemap mode for thousands of address-only records | Yes | Not listed |
| State filtering | Yes, two-letter state codes | Not listed |
| Maximum properties control | Yes, 1 to 1,000,000 | Not listed |
| Seller name and detail URL | Yes | Yes |

### Configure the run

Drive the Actor with a city-state slug for API mode, or choose Featured or Sitemap mode, then filter by state and cap the number of properties returned. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "searchSlug": "los-angeles-california",
  "stateFilter": [],
  "maxItems": 10
}
```

A larger pull:

```json
{
  "searchSlug": "los-angeles-california",
  "stateFilter": [],
  "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.01 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.00 |
| 1,000 results | $10.00 |
| 10,000 results | $100.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [ForSaleByOwner FSBO Listings Scraper](https://apify.com/parseforge/forsalebyowner-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to ForSaleByOwner through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/forsalebyowner-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that your city-state slug is correct and that the location has active listings. For Featured mode, note that only about 20 listings are available at a time. For Sitemap mode, ensure your state filter is not too restrictive.

**Why are some fields empty?**

Not every listing includes all fields. Sitemap mode only returns address data, and Featured mode returns a subset of the full API fields. Use API mode for the richest data.

**How do I find the correct city-state slug?**

Go to ForSaleByOwner.com, search for a city and state, and copy the slug from the URL. It usually looks like city-name-state-name, all lowercase with hyphens.

**Why did my run stop before reaching maxItems?**

The Actor stops when there are no more listings to fetch. If you set maxItems higher than the available listings, it will return all that exist.

**Can I get seller phone numbers?**

API mode includes owner phone when the seller has provided it. Not all listings have a phone number, so some rows may be empty.

### FAQ

| Question | Answer |
|---|---|
| What is ForSaleByOwner.com? | ForSaleByOwner.com is a US real estate marketplace where homeowners list their properties for sale directly, without a real estate agent. It includes photos, descriptions, and seller contact details. |
| What data does this Actor return? | In API mode it returns 30+ fields per listing, including address, price, beds, baths, square footage, description, photos, owner name and phone, lot size, year built, MLS number, and property features. Featured mode returns the homepage cards with about 20 listings, and Sitemap mode returns address-only records for thousands of listings. |
| How do I choose the right mode? | Use API mode when you need rich data for a specific city or state. Use Featured mode to get the latest homepage listings. Use Sitemap mode when you want maximum coverage and only need addresses. |
| What is a city-state slug? | It is a URL-friendly location identifier used by ForSaleByOwner, like los-angeles-california or miami-florida. You can find the slug in the URL when you browse listings on the site. |
| Can I filter by state? | Yes, you can provide a list of two-letter US state codes in the stateFilter input. The filter is applied after fetching, so it works with any mode. |
| How many listings can I scrape? | You can set maxItems from 1 to 1,000,000. The actual number depends on how many listings are available in your chosen mode and location. |
| Do I need an API key or login? | No, this Actor reads the public ForSaleByOwner feeds directly. You only need an Apify account to run it. |
| What output formats are supported? | You can export the results to CSV, JSON, Excel, or XML from the Apify dataset. |
| Is this legal to scrape? | You should review ForSaleByOwner.com's terms of service and comply with applicable laws. The Actor only accesses publicly available data. |
| Can I schedule this Actor to run automatically? | Yes, you can set up a schedule in Apify to run it daily, weekly, or at any interval you need. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by ForSaleByOwner.com. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `mode` (type: `string`):

API: search a city/state with rich 30+ fields (description, photos, owner, lot, year built, MLS, features). Featured: ~20 listings from homepage cards. Sitemap: address-only data for thousands of listings.

## `searchSlug` (type: `string`):

City-state slug for API mode (e.g. 'los-angeles-california', 'miami-florida', 'austin-texas'). Required when mode=api.

## `stateFilter` (type: `array`):

Filter to specific US states (2-letter codes).

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

How many properties to collect per run.

## Actor input object example

```json
{
  "mode": "api",
  "searchSlug": "los-angeles-california",
  "stateFilter": [],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchSlug": "los-angeles-california",
    "stateFilter": [],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/forsalebyowner-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 = {
    "searchSlug": "los-angeles-california",
    "stateFilter": [],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/forsalebyowner-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchSlug": "los-angeles-california",
  "stateFilter": [],
  "maxItems": 10
}' |
apify call parseforge/forsalebyowner-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/forsalebyowner-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/BvdKRnk4mxELvGYTY/builds/uNW2iBKSW2fUQLomf/openapi.json