# LandSearch Scraper (`parsebird/landsearch-scraper`) Actor

Scrape LandSearch.com land listings by URL, state, county, city, or ZIP. Filter by price, acreage, price/acre, land use, buildings, utilities, and more. JSON, CSV, Excel.

- **URL**: https://apify.com/parsebird/landsearch-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 properties

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### LandSearch Scraper

LandSearch Scraper extracts land and rural property listings from [LandSearch.com](https://www.landsearch.com/) — price, acreage, price-per-acre, location, land features, buildings, agent contacts, and more. It's a fast **LandSearch API alternative** for investors, brokers, and analysts who need structured land data without a paid MLS feed.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search by state, county, city, or ZIP, filter by price, acreage, price-per-acre, and 30+ land-feature tags (terrain, land use, buildings, utilities, natural features, activities, and deal type), and get every listing detail — MLS number, agent, price history, and full photo gallery — in one run.
</td>
</tr></table>

<br>

##### Copy to your AI assistant

```
Use the Apify actor "parsebird/landsearch-scraper" (call it via the apify-client SDK, e.g. `ApifyClient(token).actor("parsebird/landsearch-scraper").call(run_input={...})`) to scrape land listings from LandSearch.com. Key inputs: startUrls (array of LandSearch search or property URLs), searchLocations (array of free-text places like "Travis County, TX", a city, state, or ZIP), propertyTypes, listingFormat, minPrice/maxPrice, minAcres/maxAcres, minPricePerAcre/maxPricePerAcre, keywords, maxDaysOnMarket, sortBy, hasHome, minBedrooms/maxBedrooms/minBathrooms, minHomeSqft/maxHomeSqft, minYearBuilt/maxYearBuilt, terrain/landUses/buildings/utilities/naturalFeatures/activities/dealTypes (land-feature tag arrays), mustHavePhotos, listingSource, excludePending, excludeHoa, maxResults (default 10, 0 = unlimited), and includePropertyDetails (default true). Output is one JSON object per listing with id, url, title, price, acres, pricePerAcre, status, format, address/city/county/state/zip, latitude/longitude, propertyTypes, tags, bedrooms/bathrooms/homeSqft/yearBuilt, schoolDistrict, mlsName/mlsNumber, agent and brokerage contacts, thumbnailUrl/images, priceHistory, attributes, and description. Full API reference: https://apify.com/parsebird/landsearch-scraper/api. Get an API token at https://console.apify.com/account/integrations.
```

### What does LandSearch Scraper do?

LandSearch Scraper turns [LandSearch.com](https://www.landsearch.com/) search results and property pages into structured, ready-to-use data. It works two ways:

- 🔗 **Paste a LandSearch URL** — a search page (state, county, or a filtered search you already built on the site) or a single property page. Filters already baked into the URL are respected.
- 📍 **Type a location** — a state, county ("Travis County, TX"), city ("Austin, TX"), or ZIP code, then narrow it with the filters below.

Every listing can be scraped as a fast overview (title, price, acreage, location) or with **full property details**: street address, complete description, every photo, price history, land and building attributes, elevation, school district, MLS number, and agent/brokerage contacts.

Land-specific filters cover:

- 🌄 **Terrain** — waterfront, mountain, lakefront, off-grid, and more
- 🚜 **Land use** — ranch, cattle ranch, timberland, row crop, development land
- 🏚️ **Buildings** — house, cabin, barndominium, mobile home, workshop
- 💧 **Utilities** — water well, septic, solar power, fenced, irrigated
- 🌲 **Natural features** — creek, pond, wooded, mineral rights, water rights
- 🎣 **Activities** — hunting, fishing, equestrian, borders public land
- 💰 **Deal type** — owner financing, for-sale-by-owner, cheap land, distressed

Every combination of filters can be run on a **schedule**, triggered via the **Apify API**, or wired into **Zapier, Make, or n8n** integrations — so you can monitor a county for new listings, track price drops, or feed land data straight into a spreadsheet or CRM. Results export as **JSON, CSV, Excel, HTML, or RSS**.

### What data can you extract from LandSearch?

| Field | Description |
|-------|-------------|
| `price`, `acres`, `pricePerAcre` | Asking price, parcel size, and computed value-per-acre |
| `address`, `city`, `county`, `state`, `zip` | Full location breakdown |
| `latitude`, `longitude` | Parcel coordinates |
| `propertyTypes`, `tags` | Residential/commercial/agricultural/recreational classification and land-feature tags |
| `bedrooms`, `bathrooms`, `homeSqft`, `yearBuilt` | Building details, when a home is present |
| `schoolDistrict` | Assigned school district |
| `mlsName`, `mlsNumber`, `isForSaleByOwner` | Listing source |
| `agentName`, `agentPhone`, `brokerageName`, `brokeragePhone` | Contact info |
| `images`, `totalImages` | Full-size photo URLs |
| `priceHistory` | Every listing and price-change event |
| `attributes` | Grouped lot/structure/interior/exterior attributes, exactly as published |
| `description` | Full listing description text |

See [Output example](#output-example) below for the complete field list on a live listing.

### Input parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| startUrls | array | No\* | `["https://www.landsearch.com/properties/texas"]` | LandSearch search or property page URLs |
| searchLocations | array | No\* | `[]` | State, county, city, or ZIP to search |
| propertyTypes | array | No | all | `residential`, `commercial`, `agricultural`, `recreational` |
| listingFormat | string | No | `any` | `any`, `sales`, `leases`, `auctions` |
| minPrice / maxPrice | integer | No | — | Asking price range (USD) |
| minAcres / maxAcres | number | No | — | Parcel size range (acres) |
| minPricePerAcre / maxPricePerAcre | integer | No | — | Price-per-acre range (USD) |
| keywords | string | No | — | Match a word/phrase in the description |
| maxDaysOnMarket | string | No | any age | `1`, `3`, `7`, `30`, `90`, or `180` days |
| sortBy | string | No | `featured` | `featured`, `newest`, `price_high_low`, `price_low_high`, `size_large_small`, `size_small_large`, `recently_updated` |
| hasHome | string | No | `any` | `any`, `yes`, `no` |
| minBedrooms / maxBedrooms | string | No | any | `1`–`5` |
| minBathrooms | string | No | any | `1`–`4` |
| minHomeSqft / maxHomeSqft | integer | No | — | Building size range (sqft) |
| minYearBuilt / maxYearBuilt | integer | No | — | Construction year range |
| terrain, landUses, buildings, utilities, naturalFeatures, activities, dealTypes | array | No | `[]` | Land-feature tags — see [full list](#what-does-landsearch-scraper-do) |
| mustHavePhotos | boolean | No | `false` | Skip listings without photos |
| listingSource | string | No | `any` | `any`, `mls`, `non_mls` |
| excludePending | boolean | No | `false` | Skip listings with an accepted offer |
| excludeHoa | boolean | No | `false` | Skip HOA properties |
| maxResults | integer | No | `10` | Total properties to collect. `0` = every match (up to LandSearch's own 10,000-per-search limit) |
| includePropertyDetails | boolean | No | `true` | Fetch full detail (photos, description, price history, agent) per listing |

\* At least one of `startUrls` or `searchLocations` is required. Filters below `startUrls`/`searchLocations` only apply to `searchLocations` — a URL's own filters are kept as-is.

### Output example

```json
{
  "id": 5454685,
  "url": "https://www.landsearch.com/properties/2088-eagles-ridge-dr-weatherford-tx-76087/5454685",
  "title": "3 Acres of Land with Home for Sale in Weatherford, Texas",
  "price": 850000,
  "acres": 3.005,
  "pricePerAcre": 282862.0,
  "status": "active",
  "format": "sale",
  "promoted": false,
  "listedAt": "2026-07-31T22:56:46Z",
  "daysOnMarket": 1,
  "updatedAt": "2026-08-01T01:34:24Z",
  "address": "2088 Eagles Ridge Dr",
  "city": "Weatherford",
  "county": "Parker",
  "state": "Texas",
  "stateCode": "TX",
  "zip": "76087",
  "latitude": 32.650574,
  "longitude": -97.877844,
  "propertyTypes": ["Residential"],
  "tags": ["House", "Irrigated", "Septic system", "Water well", "Wooded", "Workshop"],
  "bedrooms": 4,
  "bathrooms": 2.0,
  "homeSqft": 2566,
  "yearBuilt": 2023,
  "schoolDistrict": "Brock ISD",
  "mlsName": "North Texas Real Estate Information Systems",
  "mlsNumber": "21346267",
  "isForSaleByOwner": false,
  "agentName": "Jordan Avery",
  "agentPhone": "(512) 867-5988",
  "brokerageName": "Hill Country Land Co.",
  "thumbnailUrl": "https://cdn.landsearch.com/listings/4VKMC/large/weatherford-tx-176217902.jpg",
  "totalImages": 40,
  "priceHistory": [
    { "date": "2026-08-01T00:34:11Z", "event": "New listing", "price": 850000, "status": "active" }
  ],
  "description": "Nestled within the prestigious gated community of Eagles Bluff, this custom-built estate offers..."
}
```

Download results as **JSON, CSV, Excel, HTML, or RSS** from the Apify Console, or pull them programmatically via the [dataset API](https://docs.apify.com/api/v2#/reference/datasets).

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("parsebird/landsearch-scraper").call(run_input={
    "searchLocations": ["Travis County, TX"],
    "minAcres": 20,
    "maxPricePerAcre": 15000,
    "maxResults": 200,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["price"], item["acres"])
```

#### JavaScript

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

const client = new ApifyClient({ token: "<YOUR_API_TOKEN>" });
const run = await client.actor("parsebird/landsearch-scraper").call({
    searchLocations: ["Travis County, TX"],
    minAcres: 20,
    maxPricePerAcre: 15000,
    maxResults: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use cases

- 📊 Build a **land-value model** by pulling price-per-acre across an entire county or state
- 🏞️ Monitor a target county for **new listings** or **price drops** on a schedule
- 🤠 Screen for **recreational land** — hunting, fishing, or off-grid parcels with specific natural features
- 🏦 Find **owner-financed** or **distressed** land deals for creative-financing investors
- 🏡 Source **rural homesteads** with a house, acreage minimum, and utility requirements already on-site
- 📈 Feed a CRM or BI dashboard with structured land inventory via the Apify API

### How it works

1. LandSearch Scraper resolves each `searchLocations` entry to LandSearch's own location slug (state, county, city, or ZIP) — the same one used in its site URLs.
2. It passes LandSearch's Cloudflare bot check once per run, then queries LandSearch's own listings API directly with your filters applied.
3. For each `startUrls` entry, it re-uses whatever filters, sort order, and page are already encoded in the URL.
4. When `includePropertyDetails` is on (default), it fetches the full detail record for every listing — description, photos, price history, agent, and MLS data.
5. Every listing is pushed to the dataset as soon as it's fetched, and billed via [pay-per-result](https://docs.apify.com/platform/actors/publishing/monetize#pay-per-event-pricing) — you never pay for empty runs.

### How much does it cost to scrape LandSearch?

LandSearch Scraper uses **pay-per-result** pricing — you only pay for listings actually returned, never for compute time or failed runs.

| Event | Free | Bronze | Silver / Gold |
|-------|------|--------|---------------|
| `property-scraped` (per listing) | $0.69 / 1,000 | $0.59 / 1,000 | $0.49 / 1,000 |

Scraping 1,000 listings on a Silver or Gold plan costs about **$0.49**. Apify's [monthly platform usage credits](https://apify.com/pricing) apply on top of your plan, so most light usage is covered without any extra charge.

### Input & output

The input schema groups filters into **What to scrape**, **Core search filters**, **Home & building filters**, **Land feature filters**, **Listing quality**, and **Options** — open the [Input tab](https://apify.com/parsebird/landsearch-scraper/input-schema) to see every field with examples. Every run's results are available as a dataset — export as JSON, CSV, Excel, HTML, or RSS, or read them with the [Apify API](https://docs.apify.com/api/v2) and [client libraries](https://docs.apify.com/api/client/python/) for Python and JavaScript.

### Is it legal to scrape LandSearch?

Scraping publicly available data — the kind shown on LandSearch's public search and property pages without logging in — is generally considered legal, including under rulings like *hiQ Labs v. LinkedIn*. That said, you're responsible for how you use the data: don't scrape personal data outside these fields, respect [LandSearch's Terms of Service](https://www.landsearch.com/), and consult a lawyer if you plan to redistribute the data commercially. Read more in Apify's [guide to web scraping and the law](https://blog.apify.com/is-web-scraping-legal/).

### Related Actors

Looking for other real estate or land data sources? Check out [ParseBird's Apify Store profile](https://apify.com/parsebird) for more scrapers covering property listings, jobs, and marketplace data.

### FAQ

**Does this need a LandSearch account or API key?**
No. LandSearch Scraper reads LandSearch's own public listings API — no login or key required.

**Can I search by state, county, city, or ZIP?**
Yes — `searchLocations` accepts any of those, e.g. `"Texas"`, `"Travis County, TX"`, `"Austin, TX"`, or `"76082"`.

**What's the maximum number of results per search?**
LandSearch itself caps any single search (one URL or one location) at 10,000 matching properties. Use more specific locations or filters to go deeper into a large state.

**Can I combine multiple filters at once?**
Yes. Land-feature filters (terrain, land use, buildings, utilities, natural features, activities, deal type) all narrow the same search together — a property must match every selected tag.

**Can I run this on a schedule?**
Yes — use [Apify's Scheduler](https://docs.apify.com/platform/schedules) to run it daily, weekly, or at any interval, and combine it with incremental dataset checks to catch new listings or price changes.

**What if a listing has no home on it?**
Bare-land listings simply return `null` for home-specific fields like `bedrooms`, `homeSqft`, and `yearBuilt`.

**Something looks wrong or missing — where do I report it?**
Open an issue on the Actor's Issues tab in Apify Console, or reach out via [Apify's support](https://apify.com/contact). Feedback on data accuracy is always welcome.

# Changelog

This Actor's version history is a separate document: https://apify.com/parsebird/landsearch-scraper/changelog.md

# Actor input Schema

## `startUrls` (type: `array`):

Full LandSearch.com URLs: a search page (e.g. https://www.landsearch.com/properties/texas) or a single property page. Filters already in the URL are kept and combined with the filters below.

## `searchLocations` (type: `array`):

Type a place instead of a URL: a state (Texas), county (Travis County, TX), city (Austin, TX), or ZIP (76082). Each becomes its own search using the filters below.

## `propertyTypes` (type: `array`):

Limit to one or more property types. Leave empty for all types.

## `listingFormat` (type: `string`):

Sale, lease, or auction listings only.

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

Minimum asking price in USD.

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

Maximum asking price in USD.

## `minAcres` (type: `number`):

Minimum parcel size in acres. Decimals accepted (e.g. 0.5).

## `maxAcres` (type: `number`):

Maximum parcel size in acres. Decimals accepted (e.g. 0.5).

## `minPricePerAcre` (type: `integer`):

Minimum price-per-acre — the classic land-value screen.

## `maxPricePerAcre` (type: `integer`):

Maximum price-per-acre — the classic land-value screen.

## `keywords` (type: `string`):

Match a word or phrase in the listing description, e.g. cabin, creek frontage, owner will carry.

## `maxDaysOnMarket` (type: `string`):

Only show listings posted within this many days.

## `sortBy` (type: `string`):

Order results are collected in.

## `hasHome` (type: `string`):

Require, or exclude, a building on the parcel.

## `minBedrooms` (type: `string`):

Minimum bedroom count (only applies to listings with a home).

## `maxBedrooms` (type: `string`):

Maximum bedroom count.

## `minBathrooms` (type: `string`):

Minimum bathroom count.

## `minHomeSqft` (type: `integer`):

Minimum building size in square feet.

## `maxHomeSqft` (type: `integer`):

Maximum building size in square feet.

## `minYearBuilt` (type: `integer`):

Earliest construction year.

## `maxYearBuilt` (type: `integer`):

Latest construction year.

## `terrain` (type: `array`):

Geographic setting, e.g. waterfront or off-grid.

## `landUses` (type: `array`):

How the land is used or zoned, e.g. ranch or timberland.

## `buildings` (type: `array`):

Structures present on the property, e.g. cabin or barn.

## `utilities` (type: `array`):

Infrastructure already on the property, e.g. water well or solar power.

## `naturalFeatures` (type: `array`):

Natural landscape features, e.g. creek or wooded.

## `activities` (type: `array`):

Recreational uses the land supports, e.g. hunting or fishing.

## `dealTypes` (type: `array`):

Special deal or listing conditions, e.g. owner financing or FSBO.

## `mustHavePhotos` (type: `boolean`):

Skip listings with no photos at all.

## `listingSource` (type: `string`):

MLS-listed only, or non-MLS (often listed directly by the owner).

## `excludePending` (type: `boolean`):

Skip properties that already have an accepted offer.

## `excludeHoa` (type: `boolean`):

Skip properties belonging to a homeowners association.

## `maxResults` (type: `integer`):

Total properties to collect across every URL and location. You get exactly this many when that many match — never a rounded-up batch. 0 collects every match. Each individual search (one URL or one location) can return at most 10,000 properties — a LandSearch platform limit.

## `includePropertyDetails` (type: `boolean`):

Also collect street address, full description, every photo, price history, land and building features, elevation, school district, MLS number, and agent contacts. Turn off for a faster overview (title, price, acres, and location only).

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

LandSearch is protected by Cloudflare. Residential proxies are strongly recommended.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.landsearch.com/properties/texas"
  ],
  "searchLocations": [],
  "propertyTypes": [],
  "listingFormat": "any",
  "maxDaysOnMarket": "",
  "sortBy": "featured",
  "hasHome": "any",
  "minBedrooms": "",
  "maxBedrooms": "",
  "minBathrooms": "",
  "terrain": [],
  "landUses": [],
  "buildings": [],
  "utilities": [],
  "naturalFeatures": [],
  "activities": [],
  "dealTypes": [],
  "mustHavePhotos": false,
  "listingSource": "any",
  "excludePending": false,
  "excludeHoa": false,
  "maxResults": 10,
  "includePropertyDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        "https://www.landsearch.com/properties/texas"
    ],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/landsearch-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 = {
    "startUrls": ["https://www.landsearch.com/properties/texas"],
    "maxResults": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("parsebird/landsearch-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 '{
  "startUrls": [
    "https://www.landsearch.com/properties/texas"
  ],
  "maxResults": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call parsebird/landsearch-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/landsearch-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/2Drqe6LaI01BGO8wN/builds/5bMkXFlZKpJSFASb6/openapi.json