# RentHop Scraper \[Only $3.5💰] | NYC Rentals | Broker Data (`ahmed_jasarevic/renthop-scraper`) Actor

Scrape RentHop rental listings for apartment market research and broker lead generation: rent, beds and baths, square footage, address, neighborhood and ZIP, no-fee flag, broker name and phone, photos and description.

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

## Pricing

from $3.40 / 1,000 results

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

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

## What's an Apify Actor?

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

## RentHop Scraper

Scrape rental listings from RentHop, New York City's rental marketplace, for apartment market research and broker lead generation: rent, bedrooms and bathrooms, square footage, street address and unit, neighborhood and ZIP, coordinates, the no-fee flag, listing tags, broker name and phone, all listing photos and the full description.

Use it to turn public RentHop search and rental listing pages into structured NYC rental records for market research, rent comps and broker lead generation.

### Main Use Cases

- NYC apartment market research and rent-price tracking
- Broker and agent lead generation with names, phones and listing portfolios
- Building structured rental databases by neighborhood, ZIP and bedroom count
- No-fee apartment discovery and rent analysis
- Rental listing monitoring and price-change tracking over time
- Data for proptech, rental-yield and tenant-facing products

### How It Works

![RentHop Scraper workflow: from NYC rental search to structured rent and broker records](https://api.apify.com/v2/key-value-stores/oeuA0kLOyhbRM4fzt/records/how-it-works-renthop.webp)

Looking for a reliable **RentHop scraper** or a practical **RentHop API alternative**? Paste a RentHop search URL and get structured NYC rental records for **rent comparables, no-fee apartment research and broker lead generation**. Each record includes monthly rent, bedrooms, bathrooms, square footage, address and unit, neighborhood, ZIP, coordinates, no-fee flag, broker name and profile, photos and listing URL.

Use the dataset to track rents by neighborhood, find no-fee inventory, compare broker activity, or feed rental dashboards and tenant-facing products. Export as JSON, CSV or Excel, or pull results through the Apify API. Start with a small run, then pay from $3.50 per 1,000 results.

### Extract RentHop Rental Listings Without An Official API

RentHop does not publish a developer API. This actor reads the same public search and listing pages a visitor sees:

- Start from any RentHop search URL (for example 2-bedroom apartments in New York) or a direct listing URL.
- Return rent, address, ZIP, bedrooms, bathrooms, square footage and coordinates from a single search-page request.
- Optionally enrich each listing with the exact address and unit, the full description, all photos and the broker's phone number.
- Cap the run with `maxListings`; the actor raises the page count on its own whenever more pages are needed.

### Research RentHop Broker And No-Fee Data

With detail enrichment on, each row carries the broker name, the broker phone number (brokers write it into the listing description, so it arrives with the same request) and the broker profile URL, plus the no-fee flag and listing tags. This is the dataset for broker lead generation, portfolio analysis and no-fee apartment research.

### Input Parameters

| Field | Type | Required | Default | Notes |
| --- | --- | --- | --- | --- |
| `startUrls` | array | No | `https://www.renthop.com/apartments-for-rent/new-york-ny/2-bedroom` | RentHop search or listing URLs. |
| `maxListings` | integer | No | `30` | Hard cap on returned listings. Free users are capped at 10. |
| `maxPagesPerSearch` | integer | No | `1` | Result pages per search URL (about 15 unique listings per page). A floor, not a ceiling: the actor raises it when `maxListings` needs more pages. |
| `enrichDetails` | boolean | No | `false` | Fetch each listing page for full details, photos and description. |
| `maxConcurrency` | integer | No | `5` | Parallel fetches; keep it at or above `maxPagesPerSearch`. |
| `requestDelayMs` | integer | No | derived | Leave unset: the actor derives the gap from the measured RentHop limit and adapts it. |
| `proxy` | object | No | Apify Proxy on (RESIDENTIAL, US) | Recommended for reliable detail enrichment. |

### Output Fields

One item per listing:

- `marketplace`, `listingId`, `url`: marketplace name, listing ID and listing URL.
- `address`, `unit`, `neighborhood`, `zip`, `city`, `state`: location fields.
- `monthlyRent`, `bedrooms`, `bedroomsLabel`, `bathrooms`, `squareFeet`: rent and size.
- `latitude`, `longitude`: geo-coordinates.
- `noFee`, `tags`: no-fee flag and listing tags.
- `brokerName`, `brokerPhone`, `brokerProfileUrl`: broker contact details.
- `thumbnail`, `photos`: image URLs.
- `description`, `postedAt`, `scrapedAt`: description, posted date and scrape timestamp.

Dataset view: `overview`.

### Example Input And Output

Example input:

```json
{
  "startUrls": [{ "url": "https://www.renthop.com/apartments-for-rent/brooklyn-new-york-ny/1-bedroom" }],
  "maxListings": 100,
  "enrichDetails": true,
  "maxConcurrency": 5,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

Example output row:

```json
{
  "marketplace": "RentHop",
  "listingId": "77274625",
  "url": "https://www.renthop.com/listings/fulton-street/77274625",
  "address": "100 Fulton Street, New York, NY 10038",
  "unit": null,
  "neighborhood": "Fulton Street Financial District, Downtown Manhattan, Manhattan",
  "zip": "10038",
  "city": "New York",
  "state": "NY",
  "monthlyRent": 5050,
  "bedrooms": 2,
  "bedroomsLabel": "2 Bed",
  "bathrooms": 1,
  "squareFeet": 1000,
  "latitude": 40.7096,
  "longitude": -74.0066,
  "noFee": false,
  "tags": ["Exclusive"],
  "brokerName": "Ava Hollow",
  "brokerPhone": "(347) 479-5032",
  "brokerProfileUrl": "https://www.renthop.com/managers/ava-hollow",
  "description": "Available now! Message me to tour today.",
  "postedAt": "last hour",
  "scrapedAt": "2026-10-13T09:00:00.000Z"
}
```

### Integrations & Automation

Results are written to Apify datasets, so you can export them as JSON, CSV or Excel, read them through the Apify API, or push them onward with webhooks. Connect the actor to Zapier or Make to load rows into a CRM, a spreadsheet or a BI tool.

For rent monitoring, schedule the actor daily on the same search URLs so each run records the same market over time. For slower market research, a weekly schedule is usually enough. Recurring runs also help the actor surface better in the Apify Store.

### Related Actors

- [parseforge/zillow-rentals-scraper](https://apify.com/parseforge/zillow-rentals-scraper)
- [zillowscraper/zillow-agent-rental-listings-scraper](https://apify.com/zillowscraper/zillow-agent-rental-listings-scraper)
- [themineworks/zillow-rental-listings](https://apify.com/themineworks/zillow-rental-listings)
- [benthepythondev/hotpads-rental-scraper](https://apify.com/benthepythondev/hotpads-rental-scraper)
- [swerve/redfin-rentals](https://apify.com/swerve/redfin-rentals)

### FAQ

#### Is there an official RentHop API?

RentHop does not publish a public developer API. If you need structured rental data, you either scrape the public pages or license data from a third-party provider such as RentCast. This actor reads the public pages directly, so no contract is needed.

#### What are the alternatives to this actor for rental listing data?

Alternatives include the Zillow, HotPads and Redfin scrapers listed above, third-party rental data APIs such as RentCast, and apartment-comparison datasets. This actor focuses specifically on RentHop listings, including broker name and phone.

#### Does it return broker phone numbers?

Yes, when `enrichDetails` is true. Brokers write their number into the listing description, so it arrives with the same request and there is no separate profile lookup.

#### Can I run it without detail enrichment?

Yes. With `enrichDetails: false` the actor returns search-card data only (rent, address, ZIP, beds, baths, square footage, coordinates, tags, broker and thumbnail). One search page already carries that data, so a 20-listing run is only about 2 page fetches and typically finishes in under 10 seconds.

#### How many listings can one run return?

Up to `maxListings` (the default is 30, and the actor supports up to 1000). The actor automatically requests as many search pages as the requested count needs.

### SEO Keywords

renthop scraper, renthop rentals, renthop apartments, nyc apartment rentals, new york rental data, scrape renthop, rental listing scraper, apartment rent data, broker lead generation, real estate broker data, no fee apartments, renthop api, nyc rental market research, brooklyn apartments data, manhattan rental listings, rental price monitoring, apartment market data, property data export, renthop dataset, rental listings csv, apartment scraper nyc, real estate data extraction, rental yield data, broker phone data, rental listing database

### For AI Agents & LLM Apps

Purpose: return RentHop rental listing rows (rent, size, location, broker contact) for a set of RentHop search or listing URLs.

Minimal working input:

```json
{ "startUrls": [{ "url": "https://www.renthop.com/apartments-for-rent/new-york-ny/2-bedroom" }] }
```

Variant that enriches each listing with photos, description and broker phone:

```json
{ "startUrls": [{ "url": "https://www.renthop.com/apartments-for-rent/brooklyn-new-york-ny/1-bedroom" }], "maxListings": 100, "enrichDetails": true }
```

Output fields: `marketplace`, `listingId`, `url`, `address`, `unit`, `neighborhood`, `zip`, `city`, `state`, `monthlyRent`, `bedrooms`, `bedroomsLabel`, `bathrooms`, `squareFeet`, `latitude`, `longitude`, `noFee`, `tags`, `brokerName`, `brokerPhone`, `brokerProfileUrl`, `thumbnail`, `photos`, `description`, `postedAt`, `scrapedAt`.

Behaviors an agent should know:

- `enrichDetails` defaults to false. Turning it on adds one request per listing and is what returns `photos`, `description`, `brokerPhone`, `city`, `state` and `postedAt`.
- `maxPagesPerSearch` is a floor, not a ceiling: the actor raises it automatically when `maxListings` needs more pages.
- `requestDelayMs` is derived from `maxConcurrency` and adapts automatically; leave it unset.
- Leaving `maxListings` unset uses the default of 30; free users are capped at 10.
- The Apify RESIDENTIAL proxy pinned to the US is on by default and is required for detail enrichment; datacenter IPs get blocked on listing pages.

Billing: pay-per-event. `apify-actor-start` (about $0.00005), one `apify-default-dataset-item` per row (about $0.0035) and one `listing-detail` per enriched listing that contributed photos or a full description (about $0.0025).

### Legal & Compliance Disclaimer

This actor is independent and is not affiliated with, endorsed by or sponsored by RentHop or RentHop, Inc. It reads only publicly available listing pages: it does not log in, does not bypass authentication and does not solve CAPTCHAs.

Users are responsible for complying with RentHop's Terms of Service and with applicable data-protection law (for example GDPR or CCPA) in their own jurisdiction. Where the output contains broker names or phone numbers, that data must not be used for unsolicited commercial outreach in violation of applicable law.

# Actor input Schema

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

RentHop search URLs (e.g. https://www.renthop.com/apartments-for-rent/new-york-ny/2-bedroom) or direct listing URLs (https://www.renthop.com/listings/...). Defaults to 2-bedroom apartments in New York, NY.

## `maxListings` (type: `integer`):

Maximum number of listings to return. The Actor stops as soon as this many listings have been pushed.

## `maxPagesPerSearch` (type: `integer`):

How many result pages to crawl for each search URL (each page yields roughly 15 unique listings). This is a floor, not a ceiling: the Actor raises it on its own whenever maxListings needs more pages than this, so a run never stops short of the requested count. Each page is fetched on its own verified residential IP, which then walks its own listings at RentHop's limit of about one request per 2.5 s, so more pages also means more verified IPs working in parallel — raise it yourself only to force that extra parallelism.

## `enrichDetails` (type: `boolean`):

Visit every listing page to add the exact address/unit, full description, all photos, precise beds/baths/square footage and the broker's phone number — the broker writes it into the listing description, so it comes along with the same request. Off by default: the search page already returns rent, address, zip, beds, baths, coordinates, tags, broker and thumbnail in a single request, which is what makes a run finish in seconds. Turning this on adds one request per listing, so a 20-listing run goes from ~2 requests to ~28 and takes 35-85 s instead of ~9 s.

## `maxConcurrency` (type: `integer`):

How many pages to fetch at the same time. Listings found on a search page are enriched on that same page's connection, so for a normal run this mainly caps how many search pages are crawled in parallel — set it to at least maxPagesPerSearch. 5 is a good default; 1-2 if you are not using a proxy.

## `requestDelayMs` (type: `integer`):

Starting gap between request starts, in milliseconds. Leave unset: the Actor derives it from maxConcurrency (about 2.5 s per IP, which is the measured RentHop limit) and then adapts it automatically — it doubles the gap whenever Cloudflare answers 403 and decays it back after clean responses. Set it only to force a slower or faster start.

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

Proxies used by the crawler. Defaults to Apify RESIDENTIAL proxies pinned to the US, which is what avoids the Cloudflare challenge: RentHop blocks detail pages from datacenter IPs and from non-US residential exits. Turning the proxy off uses the Apify cloud IP and usually returns search-card data only (no description, photos or broker phone).

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.renthop.com/apartments-for-rent/new-york-ny/2-bedroom"
    }
  ],
  "maxListings": 30,
  "maxPagesPerSearch": 1,
  "enrichDetails": false,
  "maxConcurrency": 5,
  "requestDelayMs": 500,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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 = {
    "startUrls": [
        {
            "url": "https://www.renthop.com/apartments-for-rent/new-york-ny/2-bedroom"
        }
    ],
    "requestDelayMs": 500,
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/renthop-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 = {
    "startUrls": [{ "url": "https://www.renthop.com/apartments-for-rent/new-york-ny/2-bedroom" }],
    "requestDelayMs": 500,
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/renthop-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 '{
  "startUrls": [
    {
      "url": "https://www.renthop.com/apartments-for-rent/new-york-ny/2-bedroom"
    }
  ],
  "requestDelayMs": 500,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call ahmed_jasarevic/renthop-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ahmed_jasarevic/renthop-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/z3K6P6UY2eZOiSybW/builds/2IDsIdXoTEX7faSxM/openapi.json