# LandWatch Scraper (`parseforge/landwatch-scraper`) Actor

Scrapes LandWatch land listings by state, property type, price, and acreage. Returns each listing as a flat row with price, acres, location, and broker contact.

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

## Pricing

from $6.00 / 1,000 results

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)

### LandWatch Scraper

**Scrape LandWatch listings for farms, ranches, and undeveloped land across all 50 states, up to a million per run.** Every listing returns price, acreage, property type, location, and broker contact details. Export to CSV, JSON, Excel, or XML.

LandWatch lists rural properties that rarely appear on generic real estate portals. Manually copying listing data from state to state is slow and error-prone. This actor reads the public search results directly, applies your filters for state, property type, price, and acreage, and returns each match in one consistent row.

| Who uses it | What they scrape LandWatch for |
|---|---|
| Land investors | Screen hundreds of listings at once for parcels that meet their exact acreage and price criteria. |
| Real estate agents | Build a prospecting list of rural landowners and broker contacts in a target state. |
| Market analysts | Track asking prices per acre for farmland, timberland, and ranch land across different regions. |
| Hunting and recreation clubs | Find large-acreage hunting or recreational parcels listed below a set budget. |

### What it does

This Actor collects LandWatch land listings by direct URL or by state and property filters, and returns each one as a flat row with price, acreage, location, and broker information.

- 🗺️ **State and property type filters:** narrow results to one state and a specific category like Farms, Ranches, or Waterfront Property.
- 💰 **Price and acreage range:** set minimum and maximum price and acreage so only parcels that fit your budget and size requirements are collected.
- 🔗 **Direct URL input:** paste any LandWatch search URL to scrape exactly the listings you are already viewing in your browser.
- 📊 **Flat row output:** every listing arrives as one row with price, acres, location, property type, and broker contact, ready for spreadsheets.

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

### What you can do with LandWatch data

**🌾 Screen farmland investments.**

An investor sets a minimum of 40 acres and a maximum price of $500,000 in Iowa to identify family farms listed for sale this week.

**🏹 Find hunting land by size and budget.**

A hunting club searches for Hunting Land in Georgia between 100 and 500 acres under $300,000 to shortlist properties for a lease or purchase.

**📈 Track rural land prices by state.**

A market analyst scrapes all Ranch listings in Montana every month and charts the median asking price per acre over time.

**🏡 Build a broker contact list.**

A real estate agent scrapes Waterfront Property listings in Florida and exports the broker names and companies to a CRM for outreach.

### Why choose this scraper

|  | What you get |
|---|---|
| **Skip the manual copy-paste** | Collect thousands of land listings in minutes instead of clicking through pages by hand. |
| **Consistent data structure** | Every listing, whether a Texas ranch or a Maine timber parcel, arrives in the same flat schema. |
| **Broker contact included** | Get the listing broker's name and company when available, useful for lead generation. |
| **Works with any state** | All 50 states are supported through the state selector or by pasting a direct URL. |

### How it compares

This Actor focuses on fast, filtered LandWatch search with a simple state and property type selector. Here is how it compares to other LandWatch scrapers on Apify.

| Feature | ParseForge | LandWatch.com⚡ $1/1K US Land, Acreage & Agents Extractor | Landwatch.com Scraper | Enterprise Grade | US Land-for-Sale Scraper (LandWatch + LandFlip + LotFlip) |
|---|---|---|---|---|
| State and property type filters | Yes, built into the input UI | Not listed | Not listed | Not listed |
| Price and acreage range filters | Yes, min and max for both | Not listed | Not listed | Not listed |
| Direct URL input | Yes | Yes | Not listed | Not listed |
| Broker contact details | Yes, when available on search pages | Yes | Yes | Not listed |
| Multi-site support (LandFlip, LotFlip) | No, LandWatch only | Not listed | Not listed | Yes |

### Configure the run

Drive the Actor from a direct LandWatch search URL or by selecting a state, property type, price range, and acreage range. Filters run as each listing is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
  "maxItems": 10
}
```

A larger pull:

```json
{
  "maxItems": 200
}
```

### Pricing

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

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.65 |
| 1,000 results | $6.50 |
| 10,000 results | $65.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 [LandWatch Scraper](https://apify.com/parseforge/landwatch-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 LandWatch 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/landwatch-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 price and acreage ranges do not conflict. For example, setting a maximum price of $10,000 and a minimum of 100 acres may return zero listings. Also verify that the state you selected has listings for the chosen property type.

**The Actor is returning fewer listings than I see on the website.**

Confirm that your maxItems setting is high enough. Also, LandWatch may show slightly different results based on your geographic location or session. Try using a direct URL from your browser.

**My direct URL is being ignored and the Actor uses the filters instead.**

Make sure the Start URL field contains a complete LandWatch search URL starting with https://www.landwatch.com. If the field is empty, the Actor falls back to the filter settings.

**The run fails with a timeout error.**

Large searches can take time. Increase the Actor's timeout setting in the run options, or reduce the maxItems to a smaller number and run multiple batches.

**Broker contact information is missing for some listings.**

Not every LandWatch listing displays broker contact details on the search results page. Listings from private sellers or aggregated feeds may omit this information.

### FAQ

| Question | Answer |
|---|---|
| Can I scrape listings from multiple states in one run? | The state filter selects one state at a time. To scrape multiple states, run the Actor once per state or use a direct URL that already spans multiple states. |
| Does this Actor require a LandWatch account or API key? | No. It reads the public listing pages directly. You do not need to register an app or obtain an API key. |
| What property types can I filter by? | You can filter by Farms, Ranches, Hunting Land, Timberland, Undeveloped Land, Homesites, Recreational Land, Horse Property, Waterfront Property, Mineral Rights, Commercial Land, and Residential Land. |
| How do I scrape a specific search I built on the LandWatch website? | Copy the full URL from your browser after applying filters on LandWatch and paste it into the Start URL field. The Actor will use that exact search. |
| Does the Actor return sold or off-market listings? | It returns listings that are publicly visible on LandWatch search pages. If a listing is no longer active on the site, it will not appear in the results. |
| Can I get the listing description and images? | The Actor collects the data available on the search result pages. For full descriptions and image URLs, you may need a detail-page scraper. |
| What export formats are supported? | You can export your dataset in CSV, JSON, Excel, or XML from the Apify platform. |
| Is there a limit on how many listings I can scrape? | You set the maximum number of listings per run, up to 1,000,000. The Actor stops when it reaches that number or when no more listings match your filters. |
| Does the Actor handle pagination automatically? | Yes. It follows the next-page links on LandWatch search results until it collects the requested number of listings or reaches the end. |
| Can I filter by county or city instead of state? | The built-in filter is by state. For county or city level searches, build the search on LandWatch and paste the resulting URL into the Start URL field. |

### 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 LandWatch, LLC. 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

## `startUrl` (type: `string`):

Direct LandWatch search URL. Overrides all filter options below. Example: https://www.landwatch.com/texas-farms-for-sale

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

How many land listings to collect per run.

## `state` (type: `string`):

US state to search in. Ignored if Start URL is provided.

## `propertyType` (type: `string`):

Type of property to search for. Ignored if Start URL is provided.

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

Minimum listing price in USD. Ignored if Start URL is provided.

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

Maximum listing price in USD. Ignored if Start URL is provided.

## `minAcres` (type: `integer`):

Minimum acreage. Ignored if Start URL is provided.

## `maxAcres` (type: `integer`):

Maximum acreage. Ignored if Start URL is provided.

## Actor input object example

```json
{
  "maxItems": 10,
  "state": "",
  "propertyType": ""
}
```

# Actor output Schema

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

Overview of property listings with key fields

## `fullData` (type: `string`):

Complete dataset with all scraped property fields

# 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 = {
    "maxItems": 10
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/landwatch-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/sq3kVwimVAdzOBc0T/builds/DFEJ9Wjvd7SXkMvbc/openapi.json