# SquareYards Scraper (`crawlerbros/squareyards-scraper`) Actor

Scrape SquareYards (squareyards.com) - India property listings. Search resale/rental listings by type x city/locality, browse new projects, fetch by URL or ID. Prices in INR, BHK/area, geo, agent, images. SSR, no auth.

- **URL**: https://apify.com/crawlerbros/squareyards-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Real estate, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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.

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

## SquareYards Scraper

Scrape **SquareYards (squareyards.com)** — one of India's largest property listings portals — for resale and rental listings, new residential projects, and their detail pages. Search by property type × city (apartments, independent houses, builder floors, villas, plots, BHK variants, office spaces, and more), browse whole cities or specific localities, or fetch listings directly by URL or ID. Each record carries prices in INR, BHK/area details, possession status, locality, geo coordinates, agent info, images, and more. HTTP-only against the public SSR pages — no auth, no proxy required.

### Data Source

> **Replacement actor.** This slot was originally planned for **99acres.com** (India property listings). 99acres is hard-blocked from Apify cloud egress — direct requests return **403** and requests via the Apify **AUTO** proxy group return **418** (Akamai bot management; no residential proxy available on the free plan). It is therefore not scrapable from Apify infrastructure.
>
> **SquareYards.com** replaces it in the same category (Indian real estate listings). Verified from Apify cloud egress: `https://www.squareyards.com/sale/apartments-for-sale-in-delhi` returns **200** (~950 KB SSR HTML) and `.../independent-houses-for-sale-in-delhi` returns **200** (~790 KB). The site serves fully server-side-rendered HTML with 25+ structured listing cards and JSON-LD blocks (`Product` for new projects, `Apartment`/`SingleFamilyResidence` for resale, `RentAction` for rentals, `ApartmentComplex` for project detail pages). No proxy, cookies, or API keys are needed. An optional Apify AUTO proxy is supported as a fallback: the actor automatically escalates through it if it ever sees 403/429 rate-limiting.

### What this actor does

- **Six modes:** `search` (property type × city), `byCity` (all types in a city), `byLocality`, `byProject` (new projects), `byUrls` (direct detail/listing URLs), `byIds` (listing-ID lookup)
- **Every property axis:** 24 property-type slugs (`apartments`, `independent-houses`, `builder-floors`, `villas`, `plots`, `studio`, `1-bhk`…`6-bhk`, `1-rk`, `furnished-properties`, `gated-community`, `office-spaces`, `shops`, `showrooms`, `owner-properties`, `warehouses`, `industrial-plots`, `lands`, `penthouses`) × 26 cities (plus free-text city/locality slugs)
- **Sale and rent:** resale listings and rental listings, each with their own fields (possession status vs furnishing, monthly rent vs full price)
- **Rich records:** price (INR), price range (projects), BHK/room counts, floor size & level, locality/sub-locality/city, geo coordinates, project name, developer, agent name/location/experience, up to 8 images
- **Detail enrichment:** `byUrls`/`byIds` fetch detail pages for amenities lists, occupancy, area served, and map coordinates
- **Empty fields are omitted**

### Output per resale / rental listing (mode = search / byCity / byLocality / byUrls)

- `listingId` — SquareYards property ID
- `listingType` — `sale` or `rent`
- `name`, `description`
- `price`, `priceCurrency` (INR), `priceText` (e.g. "₹ 5.2 Cr"), `currency`
- `propertyType` — canonical slug (`apartments`, `plots`, …)
- `unitType` (e.g. "5 BHK", "Studio"), `bedroomCount`, `bathroomCount`
- `floorSize` (e.g. "3000 sq.ft."), `floorLevel`
- `possessionStatus` — `readyToMove` / `underConstruction` / `newLaunch` (sale)
- `furnishing` — `furnished` / `semiFurnished` / `unfurnished` (rent)
- `subLocality`, `locality`, `city`, `projectName`, `societyName`
- `geoLatitude`, `geoLongitude`
- `agentName`, `agentLocation`, `agentExperienceYears`, `agentRating`
- `images[]`, `image`
- `lastUpdated` — the source's "Last Updated" stamp for the listing page
- `sourceUrl`, `scrapedAt`, `recordType` (`resaleListing` / `rentalListing`)

### Output per project (mode = byProject, or featured projects on listing pages)

- `projectId` — SquareYards project ID (from `SQY-<id>`)
- `name`, `description`, `developer`
- `price`, `priceCurrency`, `priceText` ("6.45 Cr to 7.18 Cr"), `priceRangeLow`, `priceRangeHigh`
- `priceValidUntil`, `availability`, `itemCondition`
- `units` (e.g. "3 BHK-4 BHK"), `maxAreaSqFt`, `possessionStatus`
- `subLocality`, `locality`, `city`, `image`, `images[]`
- `sourceUrl`, `scrapedAt`, `recordType` (`project`)

### Output per detail page (mode = byUrls / byIds)

- `resaleDetail` — `listingId`, `name`, `occupancy`, `description`, `amenities[]`, `addressLocality`/`addressRegion`/`streetAddress`/`areaServed`, `price`, `priceText`, `floorSize`, `unitType`, `locality`, `subLocality`, `city`, `possessionStatus`, `furnishing`, `agentName`, `agentLocation`, `geoLatitude`/`geoLongitude`, `image`, `images[]`, `sourceUrl`, `scrapedAt`
- `rentalDetail` — `listingId`, `name`, `description`, `occupancy`, `price` (monthly), `agentName`, `addressLocality`/`streetAddress`, `furnishing`, `startTime`/`endTime`, `image`, `images[]`, `sourceUrl`, `scrapedAt`
- `projectDetail` — `projectId`, `name`, `description`, `addressLocality`/`addressRegion`/`streetAddress`/`addressCountry`, `geoLatitude`/`geoLongitude`, `amenities[]`, `image`, `sourceUrl`, `scrapedAt`
- `error` — typed error records (`http_403`, `http_429`, `http_5xx`, `http_4xx`, `network`, `parse`, `not_found`, `no_data`) with `message` and `sourceUrl`, emitted when a fetch or parse fails

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `byCity` / `byLocality` / `byProject` / `byUrls` / `byIds` |
| `listingType` | string | `sale` | `sale` or `rent` (modes: search, byCity, byLocality) |
| `propertyType` | string | `apartments` | 24 options incl. `all` (modes: search, byLocality) |
| `city` | string | `delhi` | 26 cities (Delhi, Mumbai, Bangalore, Hyderabad, Pune, Chennai, Kolkata, Gurgaon, Noida, Navi Mumbai, Thane, Lucknow, Ahmedabad, Jaipur, Chandigarh, Indore, Kochi, Goa, Nagpur, Surat, Vadodara, Agra, Kanpur, Patna, Bhopal, Rajkot) — dropdown (enum) |
| `locality` | string | – | Locality slug, e.g. `dwarka` → `/sale/apartments-for-sale-in-dwarka-delhi` |
| `includeProjects` | bool | `true` | Emit featured new-project cards found on listing pages |
| `startUrls` | array | – | Detail / listing / project URLs (mode=byUrls) |
| `ids` | array | – | Listing IDs, e.g. `10504566` (mode=byIds) |
| `minPrice` | int | – | Drop listings below this price in INR (0–10,000,000,000) |
| `maxPrice` | int | – | Drop listings above this price in INR |
| `possessionStatus` | string | `any` | `readyToMove` / `underConstruction` / `newLaunch` |
| `furnishing` | string | `any` | `furnished` / `semiFurnished` / `unfurnished` |
| `maxItems` | int | `50` (prefill `25`) | Hard cap (1–1000) |
| `proxyConfiguration` | object | off | Optional Apify proxy; used automatically on 403/429 |

#### Example: 3 BHK flats for sale in Delhi

```json
{
  "mode": "search",
  "listingType": "sale",
  "propertyType": "3-bhk",
  "city": "delhi",
  "maxItems": 50
}
```

#### Example: everything for sale in a specific locality

```json
{
  "mode": "byLocality",
  "listingType": "sale",
  "propertyType": "all",
  "city": "mumbai",
  "locality": "andheri-west"
}
```

#### Example: new projects in Bangalore

```json
{
  "mode": "byProject",
  "city": "bangalore",
  "maxItems": 100
}
```

#### Example: fetch specific listings and a project by URL

```json
{
  "mode": "byUrls",
  "startUrls": [
    { "url": "https://www.squareyards.com/resale-5-bhk-3000-sq-ft-apartment-in-hamdam-apartment/10504566" },
    { "url": "https://www.squareyards.com/delhi-residential-property/eldeco-camelot/343088/project" }
  ]
}
```

#### Example: rental listings within a budget

```json
{
  "mode": "search",
  "listingType": "rent",
  "propertyType": "apartments",
  "city": "hyderabad",
  "maxPrice": 60000,
  "furnishing": "semiFurnished",
  "maxItems": 30
}
```

### Use cases

- **Real-estate market research** — price discovery by city, locality, and property type for India's metros
- **Competitive intelligence** — track project launches, developers, and price ranges (`priceRangeLow`/`High`, `possessionStatus`)
- **Lead generation** — resale/rental listings with agent name, location, and experience for outreach
- **Portfolio analytics** — bedroom/area distribution, furnishing mix, and geo-tagged listing density per locality
- **Investment watchlists** — filter by price band and possession status; dedupe by `listingId`/`projectId`

### FAQ

**What is the data source?**  SquareYards (squareyards.com), a major Indian real-estate portal covering Delhi NCR, Mumbai, Bangalore, Hyderabad, Pune, Chennai, Kolkata, and more. This actor is a third-party scraper and is not affiliated with SquareYards.

**Why did this actor replace the original slot?**  The original target, 99acres.com, is blocked from Apify cloud egress (403 direct, 418 via the Apify AUTO proxy, Akamai WAF). SquareYards is the same category (India property listings) and serves plain SSR HTML that returns 200 from Apify cloud, so it works on the free plan with no proxy or credentials.

**Is a proxy required?**  No. SquareYards serves datacenter IPs directly. If you ever enable the optional Apify AUTO proxy, the actor only uses it as a fallback when it sees 403/429 responses.

**What's the difference between sale and rent records?**  Sale records are resale listings with a full asking price in INR and a `possessionStatus`; rent records carry a monthly `price` and a `furnishing` state. Both can appear under the same property type.

**Why do some records have no price?**  Some listings (particularly new projects) don't publish a price — SquareYards marks them "price on request". Projects still carry `priceRangeLow`/`priceRangeHigh` when available; listings simply omit the field.

**Why is `possessionStatus` missing on some listings?**  The source only tags some cards (e.g. plots often show `N/A`). Missing fields are omitted rather than filled with sentinel values.

**Why do images come from two hosts?**  Listing images are served from `img.squareyards.com` and project images from `static.squareyards.com` — both are direct, unauthenticated CDN URLs that work in any browser.

**What does `byIds` resolve?**  Listing IDs (the trailing number of any resale/rental URL) resolve through SquareYards' `/resale-property/<id>` and `/rental-property/<id>` redirect endpoints. Project IDs aren't resolvable from an ID alone (the project URL slug is required), so use `byUrls` with the full project URL instead.

**How fresh is the data?**  SquareYards pages display a "Last Updated" stamp which the actor attaches to every record as `lastUpdated`. Listings are actively updated — the verified sample pages show daily new postings.

**What is `includeProjects`?**  Listing pages embed a few featured new-project cards alongside the resale results. With it on, those projects are emitted as `project` records in the same run; turn it off to get pure resale/rental listings.

**Where did `commercial-properties` go?**  SquareYards retired the umbrella `commercial-properties-for-sale-*` URL slug (404 since 2025). Commercial coverage now comes from the working per-category slugs in the dropdown: `office-spaces`, `shops`, `showrooms`, `warehouses`, and `industrial-plots`.

**Can I use a city or property type not in the dropdown?**  No — `city` and `propertyType` are enum-only in the input schema (unknown city slugs 404 on the site anyway). `locality` is free-text: you can pass any locality slug (e.g. `ranchi`, `vijayawada`, `rajajinagar`), and the actor builds the same canonical URL pattern appended to the chosen city.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `listingType` (type: `string`):

Sale (resale listings) or rent (rental listings).

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

Property category. `all` returns every category (property-for-sale-in-...).

## `city` (type: `string`):

Target city. Locality pages are built as /sale/<type>-for-sale-in-<locality>-<city>.

## `locality` (type: `string`):

Locality slug (e.g. `dwarka`, `rohini`, `andheri-west`). Appended to the city in the URL: /sale/<type>-for-sale-in-dwarka-delhi. Leave empty for city-wide pages.

## `includeProjects` (type: `boolean`):

SquareYards listing pages embed a few featured new-project cards alongside resale listings. When enabled, they are emitted as `project` records.

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

Any SquareYards property page: resale/rental listing pages, detail pages (`/resale-.../<id>`, `/rental-.../<id>`) or project pages (`/<city>-residential-property/<project>/<id>/project`).

## `ids` (type: `array`):

SquareYards listing IDs (the trailing number in any listing URL, e.g. `10504566`). Resolved via /resale-property/<id> and /rental-property/<id> redirects.

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

Drop listings priced below this amount (absolute INR). Sale prices are full amounts, rent prices are monthly.

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

Drop listings priced above this amount (absolute INR).

## `possessionStatus` (type: `string`):

Filter resale listings and projects by possession/launch status.

## `furnishing` (type: `string`):

Filter listings by furnishing state (mostly populated on rental listings).

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

Hard cap on emitted records.

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

Optional. SquareYards is openly accessible without a proxy; enable Apify proxy (AUTO) only if you need it — the actor escalates through it automatically on 403/429.

## Actor input object example

```json
{
  "mode": "search",
  "listingType": "sale",
  "propertyType": "apartments",
  "city": "delhi",
  "includeProjects": true,
  "startUrls": [],
  "ids": [],
  "possessionStatus": "any",
  "furnishing": "any",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `listings` (type: `string`):

Dataset containing all scraped SquareYards property listings and projects.

# 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 = {
    "mode": "search",
    "listingType": "sale",
    "propertyType": "apartments",
    "city": "delhi",
    "includeProjects": true,
    "startUrls": [],
    "ids": [],
    "possessionStatus": "any",
    "furnishing": "any",
    "maxItems": 25,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/squareyards-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 = {
    "mode": "search",
    "listingType": "sale",
    "propertyType": "apartments",
    "city": "delhi",
    "includeProjects": True,
    "startUrls": [],
    "ids": [],
    "possessionStatus": "any",
    "furnishing": "any",
    "maxItems": 25,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/squareyards-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 '{
  "mode": "search",
  "listingType": "sale",
  "propertyType": "apartments",
  "city": "delhi",
  "includeProjects": true,
  "startUrls": [],
  "ids": [],
  "possessionStatus": "any",
  "furnishing": "any",
  "maxItems": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call crawlerbros/squareyards-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/avFDixw6hH3h3Hot9/builds/AT2XvBquX9VCevzfW/openapi.json