# NoBroker Scraper \[$2/1K💰] | Owner-Direct Rent, Sale & PG Data (`ahmed_jasarevic/nobroker-scraper`) Actor

Extract owner-direct rent, sale and PG listings from NoBroker.in into clean dataset rows - rent, deposit, BHK, carpet area, furnishing, amenities, locality, coordinates. No browser, no login.

- **URL**: https://apify.com/ahmed_jasarevic/nobroker-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (community)
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 1,000 property listings

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## NoBroker Scraper

Extract **owner-direct rent, sale and PG listings** from [NoBroker.in](https://www.nobroker.in), India's broker-free property platform, into clean structured dataset rows — rent, deposit, maintenance, BHK, carpet area, furnishing, amenities, locality and coordinates across 27 Indian cities.

Built for relocation teams, rental-search apps, proptech data pipelines and investors tracking owner-direct supply in Bangalore, Mumbai, Delhi, Hyderabad, Pune, Chennai and beyond.

> **Read this before you run it at volume.** NoBroker publishes no public API, and its `robots.txt` disallows `/api/v3/` — the exact path this Actor reads. See [Legal & Compliance](#legal--compliance). Nothing here is legal advice; the compliance decision is yours.

### What you get

#### Build rental price benchmarks by locality

`priceInr`, `rentInr`, `depositInr`, `maintenanceInr`, `bhk`, `carpetAreaSqft` and `locality` on every row, so you can compute a real rent-per-sqft distribution per neighbourhood instead of a portal-wide average.

#### Track owner-direct supply

NoBroker's whole positioning is zero-brokerage listings. `listedBy`, `ownerName`, `active`, `premium` and `lastUpdated` let you separate genuinely owner-direct inventory from the rest of the market.

#### Compare rent, resale and PG from one Actor

`listingType` covers residential rent, residential sale, PG/hostel, and — separately — commercial rent and commercial sale. Commercial is distinct inventory on NoBroker, not a filter on residential listings.

#### Feed a relocation or tenant-matching product

`latitude`, `longitude`, `bhk`, `bhkTypes`, `furnishing`, `availableFrom`, `tenantPreferred`, `amenities[]` and `images[]` are enough to power a matching flow without calling NoBroker again at request time.

#### Reproduce and audit any row

Every row carries `searchUrl` (the search page it came from) and `searchApiUrl` (the exact filter call that returned it, including `pageNo`), so you can tell apart results from different searches and re-run them.

### How It Works

![NoBroker Scraper workflow: from Indian city and locality searches to records with rents, deposits, BHK, carpet areas, owner details, amenities and coordinates](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-nobroker-scraper.webp)

Looking for a **NoBroker scraper** or a practical **Indian rental and property data alternative**? Search by city or locality, or paste exact NoBroker search URLs, and choose residential rent, sale, PG, commercial rent or commercial sale. Each row includes listing ID, type, title, property and building type, BHK, bathrooms, carpet area, rent or sale price, deposit, maintenance, furnishing, floor, age, parking, availability, owner name and type, society, locality, city, coordinates, amenities, images and source URL.

Use the dataset for rental benchmarks, owner-direct supply tracking, relocation products, tenant matching and property-investment research. A 3 km radius is the default, with prices and BHK filters available. Export as JSON, CSV or Excel, or pull results through the Apify API. Pay from $2.00 per 1,000 listings.

#### Why the `?searchParam=...` part matters

The filter endpoint narrows by the **coordinates inside `searchParam`**, not by locality name. A URL carrying only a locality — for example `https://www.nobroker.in/property/rent/bangalore/Koramangala_search-list` — has no coordinates, so the search falls back to the city centre and returns city-wide results while still *labelled* Koramangala.

The Actor therefore:

- parses `searchParam` (plus `lat`/`lon`) out of each URL and centres the search there;
- logs the effective centre of every search, e.g. `Search URL -> mode=rent city=bangalore place="Ind Win Ecstasy Apartments" coords=12.89401,77.63010 radius=2km …`;
- **warns in the log** when a URL names a locality but carries no coordinates, so a silent city-wide result never looks like a locality search;
- skips malformed URLs and any URL that is not a `nobroker.in` address, warning about each;
- accepts URLs with or without the `https://` prefix.

### Input

| Field | Type | Default | Notes |
| --- | --- | --- | --- |
| `searchUrls` | string\[] | `[]` | Exact NoBroker search URLs, one per search. Must contain `?searchParam=...`. Each URL wins over the fields below; anything it omits falls back to them. |
| `listingType` | select | `rent` | `rent`, `buy`, `pg`, `commercial-rent`, `commercial-buy`. |
| `city` | select | `bangalore` | Any of 27 built-in city coordinates. |
| `localities` | string\[] | `[]` | Narrow by locality, e.g. `["Koramangala","HSR Layout"]`. |
| `bhkTypes` | number\[] | `[]` | BHK configurations, e.g. `[2,3]`. |
| `propertyType` | select | `""` | `AP` apartment, `IH` independent house, `VF` villa, `BF` builder floor. |
| `furnishing` | select | `""` | `FULL`, `SEMI`, `NONE`. |
| `minPrice` / `maxPrice` | integer | — | INR. Monthly rent for rent/PG, total price for buy. |
| `radiusKm` | integer | `3` | Search radius around the search centre. |
| `latitude` / `longitude` | number | — | Custom search centre, overrides the city table. |
| `maxItems` | integer | `100` | Hard cap on dataset rows for the whole run. |
| `maxPages` | integer | `10` | API pages per search (~26 listings per page). |
| `skipItems` | integer | `0` | Skip N leading listings, for chunked re-runs. |
| `maxRequestsPerCrawl` | integer | `200` | Hard cap on HTTP requests. |
| `proxy` | object | `{ useApifyProxy: false }` | Standard Apify proxy picker. Enable if you are rate-limited, or for residential India IPs. |

Free accounts are capped at **25 listings** per run; paying accounts go up to `maxItems`. The Actor stops issuing requests once the cap is hit, so a free run never burns compute.

### Output

52 fields, one row per listing:

`listingId`, `listingType`, `title`, `propertyType`, `buildingType`, `bhk`, `bhkLabel`, `bathrooms`, `balconies`, `carpetAreaSqft`, `priceInr`, `rentInr`, `salePriceInr`, `depositInr`, `maintenanceInr`, `maintenanceFormatted`, `negotiable`, `furnishing`, `facing`, `floor`, `totalFloors`, `lift`, `propertyAge`, `parking`, `powerBackup`, `waterSupply`, `availableFrom`, `leaseType`, `tenantPreferred`, `pgGender`, `foodIncluded`, `noOfActiveRooms`, `ownerName`, `ownerId`, `listedBy`, `society`, `locality`, `city`, `address`, `latitude`, `longitude`, `amenities[]`, `images[]`, `description`, `url`, `active`, `premium`, `lastUpdated`, `listingTypeApi`, `searchUrl`, `searchApiUrl`, `scrapedAt`

Field notes that change how you read the data:

- `priceInr` is the primary money field — rent/month for rent & PG, total asking price for buy. `rentInr` / `salePriceInr` disambiguate.
- PG listings report `minRent` → `rentInr` and `minDeposit` → `depositInr`, plus `pgGender`, `foodIncluded`, `noOfActiveRooms`.
- `images[]` are absolute `https://assets.nobroker.in/images/<listingId>/<file>` URLs, resolved from the relative filenames in the API's `photos[].imagesMap`.
- `amenities[]` are decoded from the API's `amenitiesMap` booleans (`LIFT` → `Lift`, `CPA` → `Covered Parking`, …).
- `listingType` is the normalised type you asked for; `listingTypeApi` is the raw value from the API. They differ for commercial, where NoBroker keeps separate inventory.
- `ownerName` is the publicly displayed lister name on the listing card. **This Actor never opens the contact-owner flow and never collects phone numbers or private contact data.**

Two dataset views ship with the Actor: **Overview** and **Search provenance**.

### Example input

Search by locality and configuration:

```json
{
  "listingType": "rent",
  "city": "bangalore",
  "localities": ["Koramangala"],
  "bhkTypes": [2, 3],
  "maxItems": 50,
  "maxPages": 3
}
```

Reproduce an exact search from the address bar:

```json
{
  "searchUrls": [
    "https://www.nobroker.in/property/sale/bangalore/Whitefield_search-list?searchParam=W3sibGF0IjoxMi45NjkxOTE1LCJsb24iOjc3LjcyMDIxNDwicGxhY2VJZCI6IkNoSUpfdkx5bUF3VnJqc1JVUWlwM0wzVTlOWSIsICJwbGFjZU5hbWUiOiI3aGl0ZWZpZWxkIn0="
  ],
  "maxItems": 100
}
```

### Example output

```json
{
  "listingId": "NB-4820117",
  "listingType": "rent",
  "title": "2 BHK Flat for rent in Ind Win Ecstasy Apartments",
  "propertyType": "AP",
  "buildingType": "AP",
  "bhk": 2,
  "bhkLabel": "2 BHK",
  "bathrooms": 2,
  "balconies": 1,
  "carpetAreaSqft": 1120,
  "priceInr": 32000,
  "rentInr": 32000,
  "salePriceInr": null,
  "depositInr": 64000,
  "maintenanceInr": 3500,
  "maintenanceFormatted": "3,500",
  "negotiable": true,
  "furnishing": "FULL",
  "facing": "East",
  "floor": 4,
  "totalFloors": 9,
  "lift": true,
  "propertyAge": "2 years",
  "parking": "CPA",
  "powerBackup": "Yes",
  "waterSupply": "Corporation",
  "availableFrom": "2026-10-20",
  "leaseType": "family",
  "tenantPreferred": "Family",
  "pgGender": null,
  "foodIncluded": null,
  "noOfActiveRooms": null,
  "ownerName": "Ramesh K",
  "ownerId": "ow-77213",
  "listedBy": "owner",
  "society": "Ind Win Ecstasy Apartments",
  "locality": "Koramangala",
  "city": "bangalore",
  "address": "80 Feet Road, Koramangala, Bangalore",
  "latitude": 12.93421,
  "longitude": 77.62604,
  "amenities": ["Lift", "Covered Parking", "Power Backup", "Corporation water supply"],
  "images": [
    "https://assets.nobroker.in/images/NB-4820117/1.jpg",
    "https://assets.nobroker.in/images/NB-4820117/2.jpg"
  ],
  "description": "2 BHK fully furnished flat in Ind Win Ecstasy, ready to move.",
  "url": "https://www.nobroker.in/property/rent/bangalore/2-bhk-flat-ind-win-ecstasy-apartments-NB-4820117",
  "active": true,
  "premium": false,
  "lastUpdated": "2026-10-03T18:12:44.000Z",
  "listingTypeApi": "rent",
  "searchUrl": "https://www.nobroker.in/property/rent/bangalore/Koramangala_search-list",
  "searchApiUrl": "https://www.nobroker.in/api/v3/multi/property/RENT/filter?pageNo=1&city=bangalore&locality=Koramangala",
  "scrapedAt": "2026-10-04T07:22:10.184Z"
}
```

### Integrations & automation

Call it over the Apify API (`POST /v2/acts/qZvY3ScSbbogTO7Bc/runs`) or from Python, JavaScript, the CLI or MCP. Datasets export as JSON, CSV, Excel, XML or RSS.

For **rental price monitoring**, a daily schedule over the same city + `localities` gives you a clean day-over-day diff on `priceInr`, `active` and `lastUpdated`. Rent and PG change far more often than sale listings, so a daily cadence is worth it for `rent` and `pg`; weekly is usually enough for `buy`.

Typical pipeline: run on a schedule → push the dataset to a warehouse or Postgres on `listingId` → alert when a tracked locality's median rent moves more than ~5% or when a tracked building gains or loses listings. `searchApiUrl` makes any row exactly reproducible when you need to check a surprise.

### Related Actors

| Actor | Why |
| --- | --- |
| [`agentx/nobroker-property-scraper`](https://apify.com/agentx/nobroker-property-scraper) | Also NoBroker, 40 normalized fields, city + transaction driven. Closest direct alternative. |
| [`automation-lab/nobroker-property-listings-scraper`](https://apify.com/automation-lab/nobroker-property-listings-scraper) | NoBroker rent/sale/PG for owner-direct inventory and price monitoring. |
| [`themineworks/nobroker-scraper`](https://apify.com/themineworks/nobroker-scraper) | 25 fields, reads the same geo-search API, MCP-ready. |
| [`jungle_synthesizer/nobroker-scraper`](https://apify.com/jungle_synthesizer/nobroker-scraper) | NoBroker by city/locality URL, standby + MCP mode. |
| [`ahmed_jasarevic/housinganywhere-scraper`](https://apify.com/ahmed_jasarevic/housinganywhere-scraper) | Same problem, different source: long-term rental listings in the UK and Europe. |

### FAQ

#### Why use this instead of the official NoBroker API?

There isn't one. NoBroker ships no public developer program, API reference or machine-readable spec. What exists on `apis.io` is a profile of a provider with **0** documented APIs, and NoBroker's own `/api/v1..v5` endpoints are disallowed in `robots.txt`. Third-party resellers do wrap this data (`realdataapi.com`, a `$9/mo` RapidAPI listing) — you're paying them to run the same request you're already running here.

#### Why not just parse the HTML?

Because there is nothing to parse. The public search pages are a Next.js App Router shell whose HTML contains only layout scaffolding and CSS. The existing GitHub scrapers for NoBroker all do BeautifulSoup over those pages and break on the next redesign.

#### Is NoBroker blocked or CAPTCHA-walled?

No. The JSON filter endpoint answers plain `curl` requests from a datacenter IP with HTTP 200 and full JSON. No headless browser, no captcha solver, no residential proxy. The `proxy` input exists only as a fallback if you get rate-limited.

#### What's the difference between `listingType` and `listingTypeApi`?

`listingType` is your normalised request. `listingTypeApi` is what the API returned. They diverge on commercial: NoBroker keeps commercial rent and commercial sale as separate inventory from residential, so a `commercial-rent` request returns rows the API labels differently from what you'd guess.

#### Does it collect owner phone numbers?

No. It reads the public listing card only, and never opens the contact-owner flow. `ownerName` is the publicly displayed lister name. If you need phone numbers, that is a different — and more sensitive — product.

#### How accurate is locality filtering?

The locality filter is passed to the API, but NoBroker applies it loosely: results still include neighbouring localities within `radiusKm`. This is why `latitude`/`longitude` exist — set them to the exact coordinates when precision matters.

### SEO Keywords

nobroker scraper, nobroker.in, rental property listing data, india rental data, owner direct rental listings, rent listings bangalore, mumbai rental listings, pg hostel data, broker free property india, property price monitoring, rental price benchmark, proptech data pipeline, relocation property data, nobroker api alternative, zero brokerage rental listings, buy property listings india, commercial property listings, carpet area sqft, rent deposit india, tenant matching data

### For AI Agents & LLM Apps

Returns owner-direct rent, sale, PG and commercial property listings from NoBroker.in as flat dataset rows, one per listing.

**Minimal input** — smallest input that produces a valid run:

```json
{ "city": "bangalore", "maxItems": 50 }
```

**Targeted search** by locality and configuration:

```json
{ "listingType": "rent", "city": "bangalore", "localities": ["Koramangala"], "bhkTypes": [2, 3], "maxItems": 50 }
```

**Reproduce a search exactly** from a pasted address-bar URL (wins over every other field):

```json
{ "searchUrls": ["https://www.nobroker.in/property/rent/bangalore/Whitefield_search-list?searchParam=W3sibGF0IjoxMi45NjkxOTE1LCJsb24iOjc3LjcyMDIxNDB9"], "maxItems": 100 }
```

**Output fields** (52): listingId, listingType, title, propertyType, buildingType, bhk, bhkLabel, bathrooms, balconies, carpetAreaSqft, priceInr, rentInr, salePriceInr, depositInr, maintenanceInr, maintenanceFormatted, negotiable, furnishing, facing, floor, totalFloors, lift, propertyAge, parking, powerBackup, waterSupply, availableFrom, leaseType, tenantPreferred, pgGender, foodIncluded, noOfActiveRooms, ownerName, ownerId, listedBy, society, locality, city, address, latitude, longitude, amenities, images, description, url, active, premium, lastUpdated, listingTypeApi, searchUrl, searchApiUrl, scrapedAt

**Behaviours an agent should know**

- `searchUrls` overrides every other search field. Each URL is authoritative for what it specifies; fields it omits fall back to `listingType`, `city`, `localities`, etc.
- A search URL **without** `?searchParam=...` has no coordinates. The run still succeeds but returns city-wide results under a locality label, and logs a warning. Do not treat that as a locality result.
- `priceInr` is rent/month for `rent` and `pg`, total price for `buy`. Read `rentInr` / `salePriceInr` when you need to disambiguate.
- `maxItems` defaults to 100 and `maxPages` to 10 (~26 listings/page), so a default run costs at most ~260 listings' worth of requests — but free accounts stop at **25 listings**, enforced before further requests are issued.
- `latitude` + `longitude` override the built-in city table. Use them when `city` is not one of the 27 built-ins, or when you need a precise centre.
- Billing is pay-per-event: **$0.002 per listing**, charged once per dataset row. `maxItems` is therefore your cost ceiling.

### Legal & Compliance

This Actor is an independent third-party tool. It is not affiliated with, endorsed by, or sponsored by NoBroker.in or NoHousing Technologies.

**What it actually accesses:** a single undocumented JSON endpoint that the NoBroker web and mobile frontends call themselves — `GET https://www.nobroker.in/api/v3/multi/property/{RENT|BUY|PG}/filter` — using only publicly visible listing data. It does not log in, does not bypass any authentication, does not solve CAPTCHAs, and does not access owner contact details or private data.

**A disclosure you need:** NoBroker publishes no public developer API or documentation. Its `robots.txt`, served at `https://www.nobroker.in/robots.txt`, disallows `/api/v3/` for all user-agents — which is the path this Actor reads. The endpoint is reachable without authentication and is not technically protected, but reachable is not the same as permitted. Read NoBroker's Terms of Service and decide for yourself whether your intended use is acceptable, and consider a licensed data provider if you need a commercial arrangement.

You are solely responsible for compliance with NoBroker's Terms of Service, `robots.txt`, and applicable law. This Actor collects no personal contact data, so GDPR/CCPA obligations around contact information do not apply to its output — but other obligations under those regimes may still apply depending on how you use derived market data. Keep request volumes modest; `maxRequestsPerCrawl` (default 200) and `maxItems` (default 100) bound a run without effort.

# Actor input Schema

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

Optional exact NoBroker search-result URLs, one per search. Paste the full URL from the NoBroker address bar - it must contain ?searchParam=... (the base64 blob holds the search coordinates NoBroker filters on). When supplied, every URL wins over the fields below; fields the URL does not specify are used as fallbacks.

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

Which NoBroker inventory to scrape: residential rent, residential sale (buy), PG/hostel, commercial rent (offices, shops, showrooms) or commercial sale. Commercial is separate inventory on NoBroker, not a filter on residential listings.

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

Indian city to search. Built-in coordinates for the major metros; for any other city supply latitude/longitude instead.

## `localities` (type: `array`):

Optional locality names to narrow the search, e.g. Koramangala, Powai. Leave empty to search the whole city.

## `bhkTypes` (type: `array`):

Bedroom configurations to include, e.g. 1, 2, 3, 4, 5. Leave empty for any.

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

Filter by building type (AP = apartment, IH = independent house, VF = villa, BF = builder floor). Leave empty for all.

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

Furnishing filter: FULL, SEMI or NONE. Leave empty for any.

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

Minimum monthly rent (rent/PG) or total price (buy) in INR.

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

Maximum monthly rent (rent/PG) or total price (buy) in INR.

## `radiusKm` (type: `integer`):

Search radius around the city centre in km.

## `latitude` (type: `number`):

Custom search centre latitude. Overrides the built-in city coordinates.

## `longitude` (type: `number`):

Custom search centre longitude. Overrides the built-in city coordinates.

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

Hard cap on listings pushed to the dataset for the whole run.

## `maxPages` (type: `integer`):

Maximum number of API result pages to fetch per search (each page holds ~26 listings).

## `skipItems` (type: `integer`):

Number of leading listings to skip, useful for chunked re-runs.

## `maxRequestsPerCrawl` (type: `integer`):

Maximum number of API requests the crawler may make.

## `proxy` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "searchUrls": [],
  "listingType": "rent",
  "city": "bangalore",
  "localities": [],
  "bhkTypes": [],
  "propertyType": "",
  "furnishing": "",
  "radiusKm": 3,
  "maxItems": 100,
  "maxPages": 10,
  "skipItems": 0,
  "maxRequestsPerCrawl": 200,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchUrls": [],
    "localities": [],
    "bhkTypes": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/nobroker-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 = {
    "searchUrls": [],
    "localities": [],
    "bhkTypes": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/nobroker-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchUrls": [],
  "localities": [],
  "bhkTypes": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call ahmed_jasarevic/nobroker-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/nobroker-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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