# Trulia Scraper \[Only $0.95💰] | US Listings | Agent Data (`ahmed_jasarevic/trulia-scraper`) Actor

Scrape Trulia US real estate listings by city or ZIP: price, beds/baths, sqft, address, agent/broker name + phone, photos, and price history. Build wholesale lead lists, monitor rents, and research markets - no official Trulia API needed.

- **URL**: https://apify.com/ahmed\_jasarevic/trulia-scraper.md
- **Developed by:** [Ahmed Jasarevic](https://apify.com/ahmed_jasarevic) (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 $0.95 / 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.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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

## Trulia Scraper — Extract US Real Estate Listings for Deal Sourcing & Price Monitoring

Scrape **Trulia** (trulia.com) for-sale, for-rent, and sold listings by city or ZIP code and get clean, machine-readable property data: **price, beds/baths, square footage, full address, agent/broker name + phone, photos, price history, and the property URL**. Built for US real estate wholesalers, buy-and-hold investors, rental comps teams, and skip-trace / direct-mail campaigns who need structured listing data at scale.

### Main Use Cases

- **Wholesale deal sourcing** — pull fresh listings across your target ZIPs every morning to spot motivated sellers and below-market inventory first.
- **Rental price monitoring** — track for-rent listings and rent levels per neighborhood or market for pricing and comps.
- **Real estate market research** — collect price, beds, baths, sqft, and property type across a metro or a single ZIP for market analysis.
- **Building a structured property database** — assemble nationwide property records with agent and broker contact details.
- **Sold-comps & price history analysis** — pull recently sold listings and per-property price history for valuation and negotiation leverage.
- **Skip-trace / direct-mail lead lists** — extract agent/broker name + phone to reach the listing agent or identify the listing brokerage.

### How It Works

Trulia is a Zillow Group marketplace protected by PerimeterX bot protection. This actor uses a **hybrid, API-first strategy** to return the cleanest-structured data with no browser required:

1. **Internal GraphQL API (primary, fastest):** POSTs to Trulia's search-results GraphQL query and reads the matching listings directly as clean JSON — no HTML parsing.
2. **`__NEXT_DATA__` JSON (automatic fallback):** if the API query is rejected, the actor re-parses the page's embedded JSON blob to pull the same listings.
3. **Detail pages (optional):** opens each listing's detail page for price history, agent phone, and enriched fields.

Everything runs on the Apify platform, so you get **API access, scheduling, proxy rotation (UNBLOCKER), and monitoring** out of the box — no scraping infrastructure to manage.

### Build Property & Rental Databases Without Official API Access

Trulia used to offer public developer APIs, but those were **sunset after its acquisition by Zillow Group**. There is **no official public Trulia API** you can call — the only remaining programmatic route is the gated Bridge Interactive partner platform for MLS-affiliated brokerages and approved vendors. This actor fills that gap for everyone else: point it at a city or ZIP code and get structured listing data you can drop into a spreadsheet, CRM, or database, without an MLS relationship or enterprise contract.

**Verified performance:** each search request returns a clean feed of structured listings (verified at **40 listings per request** against live Trulia data), which makes it dramatically cheaper and faster than manual copy-paste or DOM scraping.

### Input

Pull directly from the actor's input schema:

| Field | Type | Required | Default | Notes |
|-------|------|----------|---------|-------|
| `locations` | array | — | — | Cities or ZIP codes to search (e.g. `Los Angeles, CA`, `90210`). Each generates a Trulia search URL. |
| `startUrls` | array | — | — | Optional direct Trulia property URLs to enrich specific listings. |
| `searchType` | string | — | `for_sale` | Which listing type to search: `for_sale`, `for_rent`, or `sold`. |
| `maxItems` | integer | — | `50` | Maximum number of listings to push to the dataset. |
| `maxRequestsPerCrawl` | integer | — | `200` | Maximum number of page requests (search + detail pages). |
| `fetchDetails` | boolean | — | `false` | Also open each listing's detail page for price history, agent phone, and full feature data. Roughly doubles the request count. |
| `useApifyProxy` | boolean | — | `true` | Route requests through the Apify proxy. Trulia blocks datacenter and residential IPs, so keep this ON. |
| `proxyGroup` | string | — | `UNBLOCKER` | Apify proxy group. UNBLOCKER bypasses Trulia's PerimeterX protection. |

### Output

Each dataset item is a normalized listing record:

| Field | Description |
|-------|-------------|
| `url` | Canonical Trulia property URL |
| `title` | Property title / address |
| `price` | Numeric listing price (USD) |
| `priceDisplay` | Formatted price string (e.g. `$750,000`) |
| `listingType` | `FOR_SALE`, `FOR_RENT`, `SOLD` |
| `status` | Listing status |
| `bedrooms` / `bathrooms` | Bed and bath counts |
| `sqft` | Interior square footage |
| `lotSize` | Lot size (e.g. `0.12 acres`) |
| `propertyType` | e.g. Single Family Home, Condo |
| `streetAddress` / `city` / `state` / `zipCode` | Full address components |
| `neighborhood` | Neighborhood name |
| `latitude` / `longitude` | Property coordinates |
| `agentName` / `brokerName` | Listing agent and brokerage |
| `dateListed` | Listing date |
| `zpid` / `listingId` | Stable property and listing identifiers |
| `photos` / `heroImage` | Photo URLs |
| `sourceUrl` | Trulia search URL that produced the listing |
| `priceHistory` | (detail mode) price history records |
| `agentPhone` / `agentEmail` / `brokerPhone` | (detail mode) agent/broker contact fields |

With `fetchDetails` enabled, detail pages are pushed as **separate enriched rows** alongside the search rows.

### Example Input

```json
{
  "locations": ["Los Angeles, CA", "90210"],
  "searchType": "for_sale",
  "maxItems": 50,
  "fetchDetails": false,
  "proxyGroup": "UNBLOCKER"
}
```

### Example Output

```json
{
  "url": "https://www.trulia.com/home/123-main-st-los-angeles-ca-90001-123456789",
  "title": "123 Main St, Los Angeles, CA 90001",
  "price": 750000,
  "priceDisplay": "$750,000",
  "listingType": "FOR_SALE",
  "status": "for_sale",
  "bedrooms": 3,
  "bathrooms": 2,
  "sqft": 1800,
  "lotSize": "0.12 acres",
  "propertyType": "Single Family Home",
  "streetAddress": "123 Main St",
  "city": "Los Angeles",
  "state": "CA",
  "zipCode": "90001",
  "neighborhood": "Downtown",
  "latitude": 34.0522,
  "longitude": -118.2437,
  "agentName": "Jane Doe",
  "brokerName": "Acme Realty",
  "dateListed": "2026-08-01",
  "zpid": "123456789",
  "listingId": "987654321",
  "photos": ["https://www.trulia.com/pictures/..."],
  "heroImage": "https://www.trulia.com/pictures/...",
  "sourceUrl": "https://www.trulia.com/for_sale/Austin,TX/"
}
```

### Integrations & Automation

- **Apify API** — call the actor programmatically and pull results as JSON, CSV, Excel, or HTML.
- **Webhooks** — send new/updated listings to your CRM, Slack, or webhook endpoint.
- **Zapier / Make** — connect dataset output to Google Sheets, Airtable, or your real estate stack.

**Recommended schedule:** run **daily** for wholesale deal sourcing and rental price monitoring (listings churn fast and deals move within hours), and **weekly** for market research and sold-comps snapshots. Recurring runs keep your dataset fresh and build a historical price-trend record.

### Related Actors

- **[Flipkart Scraper](https://apify.com/ahmed_jasarevic/flipkart-scraper)** — by the same developer; scrape product catalog, pricing, and review data from India's largest e-commerce marketplace.
- **[Zillow Scraper](https://apify.com/compass/zillow-scraper)** — extract Zillow listings and Zestimate data for US real estate comps and valuation.
- **[Redfin Scraper](https://apify.com/compass/crawler-google-places)** — compare listings across the other major US real estate portal for cross-platform market signals.
- **[Realtor.com Scraper](https://apify.com/compass/realtor-scraper)** — pull Realtor.com listings for multi-source US property data.

### FAQ

#### Why use this actor instead of the official Trulia API?

There is **no official public Trulia API**. Trulia's public developer APIs (Property, Stats, Schools, Locations) were deprecated and shut down after the Zillow Group acquisition; the only remaining programmatic data path is the gated Bridge Interactive partner platform, which requires an MLS-affiliated brokerage or approved vendor relationship. If you're not an MLS partner, a scraper is the only way to get structured Trulia listing data — and this actor bypasses the PerimeterX protection that blocks naive scrapers.

#### What are alternatives to Trulia data / this actor?

Trulia's data overlaps heavily with other Zillow Group and US portal data. Common alternatives for US real estate listing data include **Zillow, Redfin, and Realtor.com** scrapers, each covering similar public listings. Pricing is a key differentiator: this actor costs **$0.95 per 1,000 listings** (plus optional detail events), versus comparable Trulia actors on the Apify Store priced at **$2.50 per 1,000 listings**, so heavy-volume runs cost roughly 60% less.

#### Can I scrape both rental and for-sale listings?

Yes. Set `searchType` to `for_sale`, `for_rent`, or `sold`, or paste a Trulia `/for_rent/`, `/for_sale/`, or `/sold/` URL into `startUrls` — those paths already encode the market. Sold listings include sold prices where Trulia exposes them.

#### Can I scrape a single property I already know about?

Yes. Paste the direct Trulia property URL (e.g. `https://www.trulia.com/home/...`) into `startUrls` to scrape just that listing. With `fetchDetails` enabled you get the richest detail: price history, agent phone, and full feature data.

#### Does this collect data without proxy issues?

Yes — the actor routes all requests through the Apify **UNBLOCKER** proxy, which is the one surface that reliably bypasses Trulia's PerimeterX protection. Datacenter and residential proxy groups both get HTTP 403 from PerimeterX, so the UNBLOCKER group is required and is set by default.

#### How should I schedule it for price monitoring?

Run daily for active listings and rental price tracking — Trulia listings change fast and price cuts matter. For historical comps and market research, a weekly snapshot is enough. Each run appends to your dataset so you build a price-trend record over time (dedupe on the stable `zpid` field).

### SEO Keywords

trulia scraper, trulia api alternative, scrape trulia listings, trulia real estate data, trulia property scraper, real estate listing scraper, us property data extraction, wholesale deal sourcing data, rental price monitoring, sold listings data, trulia zip code scraper, trulia city search, real estate lead generation, skip trace listing agent data, property database building, zillow group data, rent comps data, real estate market research, house for sale data api, fsbo and agent listings

### For AI Agents & LLM Apps

This actor is callable via the **Apify API** and the **Apify MCP server**, so any agent can run it and pull structured US real estate listing data.

- **Purpose:** returns normalized Trulia for-sale/for-rent/sold listing records (price, beds, baths, sqft, address, agent/broker, photos, price history) for one or more US cities or ZIP codes.
- **Minimal working input:**
  ```json
  {
    "locations": ["Austin, TX"],
    "searchType": "for_sale",
    "maxItems": 50
  }
  ```
- **Variant inputs:** set `searchType` to `for_rent` or `sold` for other markets; add `"fetchDetails": true` to return enriched detail rows (price history, agent phone); paste direct property URLs into `startUrls` to scrape single listings.
- **Output fields:** `url, title, price, priceDisplay, listingType, status, bedrooms, bathrooms, sqft, lotSize, propertyType, streetAddress, city, state, zipCode, neighborhood, latitude, longitude, agentName, brokerName, dateListed, zpid, listingId, photos, heroImage, sourceUrl` (plus `priceHistory, agentPhone, agentEmail, brokerPhone` when `fetchDetails` is on).
- **Behaviors an agent should know:**
  - `locations` and `startUrls` are independent: if both are set, both are scraped. Use one or the other for predictable runs.
  - `maxItems` defaults to `50` — set it explicitly to control run size and cost.
  - `fetchDetails` roughly doubles the request count and charges the `Detail item` event at $0.004 per row; leave it off for cheap broad sweeps.
  - Keep `useApifyProxy` true and `proxyGroup` on `UNBLOCKER` — the defaults — or PerimeterX will return HTTP 403.
  - `maxRequestsPerCrawl` defaults to `200` and bounds total page requests.
- **Billing:** pay-per-event — Actor start (~$0.0005/GB), `result` at **$0.00095** per listing row, and `Detail item` at **$0.004** per enriched row. A typical 50-listing run with no details is well under a dollar.

### Legal & Compliance Disclaimer

This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by Trulia or Zillow Group**. Zillow Group owns Trulia; this actor is not an official Trulia or Zillow Group product.

The actor only accesses **publicly available Trulia listing pages** — it does not bypass logins, does not access gated private account data, and does not solve CAPTCHAs (it relies on proxy routing to reach public pages).

Users are responsible for their own compliance with Trulia's Terms of Service and applicable law, including data-protection regulation (such as GDPR/CCPA where relevant) before storing or redistributing listing data. Listing agent contact data (names, phones, emails) returned by this actor should not be used for unsolicited commercial outreach in violation of applicable law (e.g. CAN-SPAM, TCPA, GDPR). This section is informational, not legal advice.

# Actor input Schema

## `locations` (type: `array`):

List of cities or ZIP codes to search, e.g. "Los Angeles, CA" or "90210". Each generates a Trulia search URL.

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

Optional: direct Trulia property URLs to scrape (e.g. https://www.trulia.com/home/...).

## `searchType` (type: `string`):

Which listing type to search for when using locations.

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

Maximum number of listings to push to the dataset.

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

Maximum number of page requests (search + detail pages).

## `fetchDetails` (type: `boolean`):

Also open each listing's detail page to get price history, agent phone, and full feature data. Roughly doubles the request count.

## `useApifyProxy` (type: `boolean`):

Route requests through the Apify proxy. Trulia blocks datacenter and residential IPs, so keep this ON with the UNBLOCKER group.

## `proxyGroup` (type: `string`):

Apify proxy group to use. UNBLOCKER bypasses Trulia's PerimeterX protection (datacenter/residential groups get 403).

## Actor input object example

```json
{
  "locations": [
    "Los Angeles, CA",
    "90210"
  ],
  "searchType": "for_sale",
  "maxItems": 50,
  "maxRequestsPerCrawl": 200,
  "fetchDetails": false,
  "useApifyProxy": true,
  "proxyGroup": "UNBLOCKER"
}
```

# 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 = {
    "locations": [
        "Los Angeles, CA",
        "90210"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_jasarevic/trulia-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 = { "locations": [
        "Los Angeles, CA",
        "90210",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_jasarevic/trulia-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 '{
  "locations": [
    "Los Angeles, CA",
    "90210"
  ]
}' |
apify call ahmed_jasarevic/trulia-scraper --silent --output-dataset

```

## MCP server setup

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