# Property Listing Data Feed (`nominal_cocktail/my-actor`) Actor

Extract rental availability, rent, beds, and baths directly from public listing pages—fast, reliable, and without crawling detail pages.

- **URL**: https://apify.com/nominal\_cocktail/my-actor.md
- **Developed by:** [Brenton](https://apify.com/nominal_cocktail) (community)
- **Categories:** Real estate, AI, Automation
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.08 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

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

Rental Listings Scraper (List Page Only)
Overview

This Actor extracts rental availability data directly from public rental listing pages where all key information is displayed on the listing cards themselves — without opening individual detail pages.

It is designed for speed, reliability, and low cost, making it ideal for AI assistants, CRMs, property managers, and automation workflows that need up-to-date rental inventory data.

What this Actor does

Scrapes rental listings directly from listing pages

Does not open individual unit detail pages

Supports pagination

Outputs clean, structured data suitable for AI and automation

This approach is significantly faster and more efficient than traditional scrapers that crawl each listing individually.

Data extracted

For each rental listing, the Actor extracts:

Address

Rent

Raw value (e.g. $1,400)

Parsed numeric value (e.g. 1400)

Bedrooms

Bathrooms

Availability status (e.g. NOW, Available Now)

Source page URL

Scrape timestamp

Example output
{
  "address": "1613 Benson Street, Bowling Green, KY 42103",
  "rentRaw": "$1,400",
  "rentAmount": 1400,
  "bedrooms": 3,
  "bathrooms": 1,
  "availability": "NOW",
  "pageUrl": "https://example.com/listings",
  "scrapedAt": "2026-01-04T13:50:00Z"
}

Supported websites

This Actor works with many rental and property management websites where listing data is visible directly on the listing page, including:

Property management company websites

Apartment and single-family rental listings

AppFolio-style public listing pages

Custom real estate listing sites

⚠️ This Actor only works on public listing pages.
It does not scrape logged-in dashboards or private systems.

Common use cases

Feeding AI receptionists with live rental availability

Keeping a CRM or spreadsheet updated with current listings

Monitoring availability or price changes

Powering real estate automations and workflows

Exporting rental inventory for analytics or reporting

How to use this Actor
Step 1: Find the listing page URL

Identify the public page where rental listings appear in a list or grid.

Examples:

https://example.com/rentals

https://example.com/available-homes

https://example.com/listings/apartments

The page must display:

Address

Rent

Beds/Baths

Availability
directly on the listing cards.

Step 2: Enter the listing page URL

In the Actor input:

If your URL appears in the dropdown, you can select it.

Otherwise, click “Source” (JSON view) and enter your own URL.

Single URL example (Source view)
{
  "listingPageUrls": "https://example.com/rentals",
  "maxListings": 500,
  "maxPages": 100
}

Step 3: Configure limits (optional)
Field	Description
maxListings	Stop after this many listings are extracted
maxPages	Safety limit to prevent infinite pagination

Defaults work well for most sites.

Step 4: Run the Actor

Click Run.
The Actor will:

Visit each listing page

Extract data from every listing card

Follow pagination if available

Save results to a dataset

Step 5: Export your data

After the run finishes:

Open the Dataset

Export as:

JSON

CSV

Excel

Use the data in:

AI assistants

CRMs

Spreadsheets

Automation tools

Performance & efficiency

No browser rendering

No detail-page crawling

Fast execution

Low compute usage

Suitable for scheduled runs (daily / hourly)

Important notes

Always ensure you have permission to scrape the target website

Respect website terms of service and robots.txt

Public listing pages only

Troubleshooting
No listings found

Confirm the page shows listings without clicking into details

Some sites load listings dynamically; those may require a browser-based scraper

Availability missing

Some pages display availability in multiple places; the Actor uses the most common patterns

Who this Actor is for

Property managers

Real estate teams

AI and automation agencies

CRM integrators

Developers and no-code builders

Version history
v1.0.0

Initial release

List-page-only scraping

Address, rent, beds, baths, availability extraction

Pagination support

Support & customization

This Actor is designed to work across many listing page layouts.
If you need extended fields, custom selectors, or AI-ready formatting, this Actor can be adapted for advanced workflows.

# Actor input Schema

## `listingPageUrls` (type: `string`):

One or more public listing page URLs (one URL per line).
## `maxListings` (type: `integer`):

Stop after extracting this many listings.
## `maxPages` (type: `integer`):

Safety limit for pagination to avoid infinite loops.

## Actor input object example

```json
{
  "listingPageUrls": "https://www.example.com/listings",
  "maxListings": 500,
  "maxPages": 100
}
````

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nominal_cocktail/my-actor").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("nominal_cocktail/my-actor").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 '{}' |
apify call nominal_cocktail/my-actor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Property Listing Data Feed",
        "description": "Extract rental availability, rent, beds, and baths directly from public listing pages—fast, reliable, and without crawling detail pages.",
        "version": "0.0",
        "x-build-id": "3NUQhvz0LNLp9KTli"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nominal_cocktail~my-actor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nominal_cocktail-my-actor",
                "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/nominal_cocktail~my-actor/runs": {
            "post": {
                "operationId": "runs-sync-nominal_cocktail-my-actor",
                "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/nominal_cocktail~my-actor/run-sync": {
            "post": {
                "operationId": "run-sync-nominal_cocktail-my-actor",
                "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",
                "required": [
                    "listingPageUrls"
                ],
                "properties": {
                    "listingPageUrls": {
                        "title": "Listing page URL(s)",
                        "type": "string",
                        "description": "One or more public listing page URLs (one URL per line).",
                        "default": "https://www.example.com/listings"
                    },
                    "maxListings": {
                        "title": "Maximum listings",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Stop after extracting this many listings.",
                        "default": 500
                    },
                    "maxPages": {
                        "title": "Maximum pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Safety limit for pagination to avoid infinite loops.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
