# Places4Students Listings Scraper (`piotrv1001/places4students-listings-scraper`) Actor

The Places4Students Listings Scraper extracts student housing listings from Places4Students — capturing rent, bedrooms, bathrooms, availability, distance to campus, coordinates and photos, plus optional full details — ideal for housing market research and rental search tools.

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

## Pricing

from $2.00 / 1,000 listings

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### 🎓 Places4Students Listings Scraper

Extract **off-campus student housing listings from Places4Students** for any school in Canada or the United States. The **Places4Students Listings Scraper** turns the site's per-school listing pages into clean, structured data — rent, bedrooms, bathrooms, location, distance to campus, photos and more — ready for analysis, market research, or building your own housing search.

Just enter one or more schools, pick the listing types you want, and download the results as JSON, CSV, Excel or HTML. Run it on demand or [schedule it](https://docs.apify.com/platform/schedules) to track a housing market over time, and connect it to your stack through the [Apify API](https://docs.apify.com/api/v2) and [integrations](https://apify.com/integrations).

### ✨ Features

- 🏠 **Rich listing data** – title, housing type, bedrooms, bathrooms, rent, currency, availability date, coordinates and cover image for every listing.
- 🎯 **Search by school** – enter a school name, city, slug or numeric ID; the scraper matches it against the full Places4Students directory of 1,600+ schools.
- 🗂️ **All listing categories** – Properties, Sublets, Roommates, and Faculty & Staff — choose any combination.
- 🔍 **Optional full details** – flip on _Scrape listing details_ to also collect the full street address, landlord name, complete description, lease terms, per-campus commute times (walk / bike / drive), and every listing photo.
- 🧹 **Automatic de-duplication** – listings shared across nearby schools are collapsed to unique entries by listing ID.
- ⚡ **Reliable** – no login required; runs with residential proxy out of the box for consistent results.

### 🛠️ How to use the Places4Students Listings Scraper

1. **Add schools** – enter one or more school names (e.g. `Brock University`), cities, or numeric school IDs in the **Schools** field.
2. **Choose listing types** – select Properties, Sublets, Roommates and/or Faculty & Staff.
3. **(Optional) Enable details** – turn on **Scrape listing details** for full addresses, descriptions, lease terms and photos.
4. **Set a limit** – use **Max items** to cap how many listings you collect.
5. **Run it** – click **Start** and download your data once the run finishes.

### 📊 Input

| Field                      | Description                                                                                                           |
| -------------------------- | --------------------------------------------------------------------------------------------------------------------- |
| **Schools**                | School names, cities, slugs, or numeric IDs to scrape listings for.                                                   |
| **Listing types**          | Which categories to collect: Properties, Sublets, Roommates, Faculty & Staff.                                         |
| **Scrape listing details** | If enabled, visits each listing to collect address, landlord, description, lease terms, commute times and all photos. |
| **Max items**              | Maximum number of unique listings to collect.                                                                         |
| **Proxy configuration**    | Proxy settings. Residential proxy is recommended and used by default for reliable results.                            |

### 📤 Output

Each listing becomes one row in the dataset. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Example (shallow listing):

```json
{
    "id": 277138,
    "skuCode": "BrockU-277138",
    "listingType": "properties",
    "schoolId": 133,
    "schoolName": "Brock University - St. Catharines, ON",
    "url": "https://www.places4students.com/schools/133/listings/properties/277138",
    "title": "Fully furnished bedrooms in a Two bedroom Apartment",
    "housingType": "Bedroom(s) in a Basement Apartment",
    "bedrooms": 2,
    "washrooms": 1,
    "price": 729,
    "currency": "CAD",
    "rateDescription": "per room / month",
    "occupancyDate": "Immediately",
    "distanceText": "3.6 km",
    "latitude": "43.1122279",
    "longitude": "-79.2349538",
    "isFeatured": true,
    "imageUrl": "https://p4s-cdn.b-cdn.net/tenants/p4s/storage/members/0000/163/101/277138_8771.jpg"
}
````

With **Scrape listing details** enabled, each row additionally includes `address`, `city`, `province`, `zip`, `landlordName`, `description`, `leasePeriod`, `leaseCondition`, `distances` (per-campus commute times), `coverImage` and the full `images` array.

#### Data fields

| Field                                     | Description                                     |
| ----------------------------------------- | ----------------------------------------------- |
| `id` / `skuCode`                          | Unique listing identifiers                      |
| `listingType`                             | properties / sublets / roommates / facultystaff |
| `schoolName`                              | School the listing was found under              |
| `title` / `housingType`                   | Listing title and housing category              |
| `bedrooms` / `washrooms`                  | Room counts                                     |
| `price` / `currency` / `rateDescription`  | Rent and rate basis                             |
| `occupancyDate`                           | Availability                                    |
| `distanceText` / `distanceMeters`         | Distance to campus                              |
| `latitude` / `longitude`                  | Coordinates                                     |
| `imageUrl`                                | Cover photo                                     |
| `url`                                     | Link to the listing detail page                 |
| `address` / `city` / `province` / `zip` \* | Full location                                   |
| `landlordName` \*                          | Landlord / company name                         |
| `description` \*                           | Full listing description                        |
| `leasePeriod` / `leaseCondition` \*        | Lease terms                                     |
| `distances` \*                             | Per-campus walk / bike / drive times            |
| `images` \*                                | All listing photos                              |

\* only when **Scrape listing details** is enabled.

### 💰 How much does it cost to scrape Places4Students?

This Actor uses **pay-per-result** pricing, so you only pay for the data you get:

| Event          | Price      | When it's charged                       |
| -------------- | ---------- | --------------------------------------- |
| Listing        | **$0.002** | Per listing collected (shallow mode)    |
| Listing detail | **$0.006** | Per listing collected with full details |

For example, 500 shallow listings cost about **$1.00**, and 200 full-detail listings cost about **$1.20**. Use **Max items** to keep every run within budget. New Apify accounts include monthly free usage to get started.

### 💡 Tips

- Start with a small **Max items** value to preview the data shape before a large run.
- Keep **Scrape listing details** off when you only need rent, location and room counts — it's cheaper and faster.
- Enter a **numeric school ID** for the most precise targeting when a name matches several schools.
- Listings are shared across nearby schools; the Actor already de-duplicates by listing ID, so unique inventory may be smaller than the raw per-school totals.

### ❓ FAQ

**Is scraping Places4Students legal?**
This Actor collects only publicly available listing information. As with any scraping, you are responsible for how you use the data and for complying with Places4Students' terms and applicable laws. It does not collect private contact details that are gated behind contact forms.

**Which countries are covered?**
Both Canada and the United States, wherever Places4Students lists schools.

**Can I get landlord phone numbers and emails?**
Contact is handled through Places4Students' own forms, so raw emails and phone numbers are generally not exposed publicly and are not scraped.

### 🆘 Support

Found a bug or need a data field that isn't included? Open an issue on the Actor's **Issues** tab and we'll take a look. Custom scraping solutions are available on request.

# Actor input Schema

## `schools` (type: `array`):

Schools to scrape listings for. Enter a school name (e.g. "Brock University"), a city, a slug, or a numeric school ID. Each entry is matched against the school directory.

## `listingTypes` (type: `array`):

Which categories of listings to scrape.

## `scrapeDetails` (type: `boolean`):

Visit each listing's detail page to also collect full address, landlord name, description, lease terms, per-campus commute times and all photos. Slower and more expensive.

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

Maximum number of unique listings to collect (across all schools and types).

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

Proxy settings. Residential proxy is required for reliable results and is used by default.

## Actor input object example

```json
{
  "schools": [
    "Brock University"
  ],
  "listingTypes": [
    "properties"
  ],
  "scrapeDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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 = {
    "schools": [
        "Brock University"
    ],
    "listingTypes": [
        "properties"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("piotrv1001/places4students-listings-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 = {
    "schools": ["Brock University"],
    "listingTypes": ["properties"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("piotrv1001/places4students-listings-scraper").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 '{
  "schools": [
    "Brock University"
  ],
  "listingTypes": [
    "properties"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call piotrv1001/places4students-listings-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Places4Students Listings Scraper",
        "description": "The Places4Students Listings Scraper extracts student housing listings from Places4Students — capturing rent, bedrooms, bathrooms, availability, distance to campus, coordinates and photos, plus optional full details — ideal for housing market research and rental search tools.",
        "version": "0.0",
        "x-build-id": "Hyn3X21C8xcpW4c4P"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/piotrv1001~places4students-listings-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-piotrv1001-places4students-listings-scraper",
                "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/piotrv1001~places4students-listings-scraper/runs": {
            "post": {
                "operationId": "runs-sync-piotrv1001-places4students-listings-scraper",
                "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/piotrv1001~places4students-listings-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-piotrv1001-places4students-listings-scraper",
                "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": [
                    "schools"
                ],
                "properties": {
                    "schools": {
                        "title": "Schools",
                        "type": "array",
                        "description": "Schools to scrape listings for. Enter a school name (e.g. \"Brock University\"), a city, a slug, or a numeric school ID. Each entry is matched against the school directory.",
                        "default": [
                            "Brock University"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "listingTypes": {
                        "title": "Listing types",
                        "type": "array",
                        "description": "Which categories of listings to scrape.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "properties",
                                "sublets",
                                "roommates",
                                "facultystaff"
                            ],
                            "enumTitles": [
                                "Properties",
                                "Sublets",
                                "Roommates",
                                "Faculty & Staff"
                            ]
                        },
                        "default": [
                            "properties"
                        ]
                    },
                    "scrapeDetails": {
                        "title": "Scrape listing details",
                        "type": "boolean",
                        "description": "Visit each listing's detail page to also collect full address, landlord name, description, lease terms, per-campus commute times and all photos. Slower and more expensive.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of unique listings to collect (across all schools and types).",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Residential proxy is required for reliable results and is used by default.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
