# Landsearch Property Listings Extractor (`kawsar/landsearch-property-listings-extractor`) Actor

A LandSearch scraper that collects land prices, acreage, location, coordinates, and photos from any LandSearch results URL, so you can research rural land markets and export clean data fast.

- **URL**: https://apify.com/kawsar/landsearch-property-listings-extractor.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Real estate, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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

## LandSearch Property Listings Extractor

Turn any LandSearch search page into clean, structured data. Paste one or more LandSearch results URLs, run the actor, and get every listing on the page as rows you can open in Excel or Google Sheets, drop into a database, or pull straight from the API.

If you work with rural land, acreage, farms, ranches, or vacant lots, this scraper saves you from copying listings by hand. It is built for land investors, real estate agents and brokers, appraisers, GIS and market analysts, and developers who need LandSearch inventory in a format they can actually use.

### Why use this actor

- **No manual copying.** One URL in, a full dataset out.
- **Follows pagination for you.** You are not stuck with the first page of results.
- **Real coordinates.** Every listing includes latitude and longitude, so you can map parcels or join them to GIS layers.
- **Filter-aware.** Whatever filters you set on LandSearch (rural tag, acreage range, price range, property type) are kept, because the actor reads the exact URL you paste.
- **Ready for spreadsheets and pipelines.** Export to Excel, CSV, JSON, XML, or Google Sheets, or hit the dataset API from your own code.

### What it extracts

Each listing is returned as a structured record:

| Field | Type | Description |
|-------|------|-------------|
| `listingId` | string | LandSearch listing identifier |
| `listingKey` | string | Internal feed key for the listing |
| `listingTitle` | string | Listing headline, e.g. "10 Acres of Land for Sale in Fountain Inn, South Carolina" |
| `price` | number | Asking price as a plain number (e.g. `310000`) |
| `currency` | string | Price currency (`USD`) |
| `acres` | number | Lot size in acres as a number (e.g. `10`) |
| `sizeText` | string | Original size label, e.g. "10 acres" |
| `city` | string | City |
| `state` | string | Two letter state code, e.g. `SC` |
| `zipCode` | string | ZIP code |
| `county` | string | County name |
| `latitude` | number | Parcel latitude |
| `longitude` | number | Parcel longitude |
| `coverImage` | string | Main listing photo URL |
| `listingSource` | string | Origin of the listing feed |
| `postedLabel` | string | How recently the listing was posted, e.g. "22 days" |
| `propertyUrl` | string | Direct link to the listing on LandSearch |
| `sourceUrl` | string | The results URL the listing came from |
| `scrapedAt` | string | ISO 8601 timestamp of extraction |

Fields that a listing does not publish come back as `null`, so your columns stay consistent across every row.

### How to use it

1. Go to [LandSearch](https://www.landsearch.com) and search for the area or filter you want. For example, rural land in a city, all listings in a county, or an acreage and price range.
2. Copy the results URL straight from your browser's address bar.
3. Open this actor and paste the URL into the **LandSearch results URLs** field. Add as many URLs as you like to cover several areas in one run.
4. Optionally set **Max listings** to cap how many records you collect.
5. Click **Start**. When the run finishes, download the data in your preferred format from the **Storage** tab, or read it from the API.

#### Input

| Input | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `searchUrls` | array of strings | Yes | n/a | One or more LandSearch results URLs. |
| `maxItems` | integer | No | 40 | Maximum listings to collect across all URLs (up to 40). |
| `requestTimeoutSecs` | integer | No | 45 | Per request timeout in seconds. |

#### Example input

```json
{
    "searchUrls": [
        "https://www.landsearch.com/properties/fountain-inn-sc/filter/tag=rural"
    ],
    "maxItems": 40
}
```

#### Example output

```json
{
    "listingId": "5462250",
    "listingKey": "3yd-GGARSC-1599803",
    "listingTitle": "10 Acres of Land for Sale in Fountain Inn, South Carolina",
    "price": 310000,
    "currency": "USD",
    "acres": 10,
    "sizeText": "10 acres",
    "city": "Fountain Inn",
    "state": "SC",
    "zipCode": "29644",
    "county": "Greenville County",
    "latitude": 34.6821,
    "longitude": -82.2006,
    "coverImage": "https://cdn.landsearch.com/listings/4VQ4d/small/fountain-inn-sc-176499828.jpg",
    "listingSource": "listhub",
    "postedLabel": "22 days",
    "propertyUrl": "https://www.landsearch.com/properties/tall-pines-rd-fountain-inn-sc-29644/5462250",
    "sourceUrl": "https://www.landsearch.com/properties/fountain-inn-sc/filter/tag=rural",
    "scrapedAt": "2026-08-27T04:39:25.897594+00:00"
}
```

### What kind of URLs work

Anything that returns a list of properties on LandSearch. A few examples:

- A city: `https://www.landsearch.com/properties/fountain-inn-sc`
- A city with a tag filter: `https://www.landsearch.com/properties/fountain-inn-sc/filter/tag=rural`
- A county or state results page
- Any results page with LandSearch's own filters applied (acreage, price, property type)

Set your filters on LandSearch first, then copy the URL. The actor keeps every filter that is already in the link, so what you see on the site is what you get in the dataset.

### Use cases

- **Land market research.** Build datasets of rural land prices and acreage across cities, counties, and states, then compare price per acre.
- **Deal sourcing.** Spot new acreage listings in target areas as they appear instead of refreshing the site.
- **Comparable analysis.** Pull recent listings near a subject parcel to support a valuation or offer.
- **CRM and inventory feeds.** Push fresh LandSearch inventory into your own systems for agents and clients.
- **Mapping and GIS.** Use the latitude and longitude on every record to plot parcels or join them to zoning, soil, or flood layers.
- **Price and inventory monitoring.** Run the actor on a schedule and track how listings and prices change over time.

### Exporting your data

Every run stores results in an Apify dataset. From there you can:

- Download as **Excel, CSV, JSON, XML, or HTML** from the Storage tab.
- Send results directly to **Google Sheets**.
- Read the dataset through the **Apify API** in any language.
- Connect to **Make, Zapier, or n8n** through Apify integrations to move data into other tools automatically.

### Running on a schedule

Use the **Schedules** tab in Apify to run this actor automatically, for example every morning. Each run appends a fresh, timestamped snapshot, which makes it easy to build a history of a market and see what changed between runs.

### Performance and limits

- LandSearch returns 50 listings per results page. The actor reads the total result count and fetches only as many pages as it needs to reach your **Max listings** value.
- **Max listings** can be set up to 40 per run. To cover a large area, split it into several focused searches (by county, price band, or acreage range) and pass them together in `searchUrls`.
- Duplicate listings are removed within a run, so the same parcel is never pushed twice even when it appears in more than one of your URLs.

### Frequently asked questions

**Do I need an account or login?**
No. Paste a public LandSearch results URL and run.

**Does it handle more than one page of results?**
Yes. Pagination is automatic, up to your Max listings limit.

**Can I scrape several searches in one run?**
Yes. Add multiple URLs to the results URLs field and they are all processed in the same job, with duplicates removed.

**What if a listing has no price or missing details?**
Missing fields are returned as `null` so your table stays uniform. Listings marked "contact for price" come back with `price` as `null`.

**What formats can I export?**
Excel, CSV, JSON, XML, and HTML, plus Google Sheets and the Apify API and integrations.

**Is the data structured or raw HTML?**
Fully structured. Each listing is a clean record with typed fields, ready for analysis.

### Notes on responsible use

This actor collects publicly visible listing information from LandSearch results pages. Use the data in line with LandSearch's terms and applicable laws, and be considerate with how often you run large jobs.

# Actor input Schema

## `searchUrls` (type: `array`):

One or more LandSearch search or results pages to extract listings from. Paste a full LandSearch results URL for any city, county, state or filtered search (rural land, acreage, price range). Pagination is handled automatically.

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

Maximum number of property listings to collect across all results URLs.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "searchUrls": [
    "https://www.landsearch.com/properties/fountain-inn-sc",
    "https://www.landsearch.com/properties/fountain-inn-sc/filter/tag=rural"
  ],
  "maxItems": 40,
  "requestTimeoutSecs": 45
}
```

# Actor output Schema

## `properties` (type: `string`):

Extracted LandSearch land and property listings with prices, acreage, location, coordinates and images.

# 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 = {
    "searchUrls": [
        "https://www.landsearch.com/properties/fountain-inn-sc/filter/tag=rural"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kawsar/landsearch-property-listings-extractor").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 = { "searchUrls": ["https://www.landsearch.com/properties/fountain-inn-sc/filter/tag=rural"] }

# Run the Actor and wait for it to finish
run = client.actor("kawsar/landsearch-property-listings-extractor").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 '{
  "searchUrls": [
    "https://www.landsearch.com/properties/fountain-inn-sc/filter/tag=rural"
  ]
}' |
apify call kawsar/landsearch-property-listings-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kawsar/landsearch-property-listings-extractor"
        }
    }
}

```

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/amdS53aMC3RvzhQwn/builds/8zc8KeanBdkwfpbc5/openapi.json