# Floor Plan Scraper: Home Floor Plans & Photos by Address (`scrapebench/property-floor-plan-finder`) Actor

Give a US address, get that home's floor plans — plan images and interactive 3D-scan plans kept apart from the photos — plus the listing link. Pay per floor plan found.

- **URL**: https://apify.com/scrapebench/property-floor-plan-finder.md
- **Developed by:** [ScrapeBench](https://apify.com/scrapebench) (community)
- **Categories:** Real estate
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / floor plan found

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?

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

## Floor Plan Scraper: Home Floor Plans & Photos by Address

### Pain points

- A listing's floor plan is buried in its photo gallery: on a 36-photo Redfin listing the plan is one image among the kitchen and bedroom shots, with nothing in the gallery data saying which one.
- Looking plans up for a list of homes means opening every listing and scrolling every gallery; most homes have none, so most of that clicking finds nothing.
- Interactive 3D-scan floor plans (CubiCasa) open in their own viewer, so collecting their links by hand means clicking into each tour.

### What we solve

- Returns only the floor plans for each address, already separated from the photos: plan images Redfin itself labels as floor plans, and interactive CubiCasa scans with their viewer link.
- Tells you plainly when a home has no public floor plan (hasFloorPlan: false), so a list sorts itself into 'has a plan' and 'doesn't'.
- Checks a whole list of addresses in one run, with the listing link for each so you can open the page.

### Summary

Give it US street addresses and it returns each home's floor plans, kept apart from the photos: plan images that Redfin labels as floor plans (with Redfin's caption, e.g. 'Main residence layout') and interactive CubiCasa 3D-scan plans with an image preview and a viewer link. Each row also carries the listing link, the property's address, type, beds, baths, size, year built and listing status, and optionally the full photo gallery. Most homes publish no floor plan: in a sample of 28 homes for sale on 2026-10-28, 10 had one, and off-market homes rarely do, so a row says hasFloorPlan: false when there is none. Optionally checks Realtor.com too. You pay a small fee per address checked and a fee per floor plan found; an address no site can find is free.

### Who it's for

- Architects, builders and modular-home makers benchmarking the layouts of recent homes of a given type
- Real-estate investors and agents comparing layouts across a shortlist
- Proptech and data teams adding floor plans to a property database
- Interior designers, stagers and renovation firms preparing for a site visit

### How to use

Set the input, run the actor, and collect results from the run's dataset (export to JSON/CSV/Excel, or pull via the Apify API). Example input:

```json
{
  "addresses": [
    "12307 Boneta Cv, Austin, TX 78729",
    "6107 Felix Ave, Austin, TX 78741"
  ]
}
```

See **Inputs** below for every available field.

### What you get

One row per record:

| Field | Description |
|---|---|
| `query` | The address you asked for |
| `hasFloorPlan` | True when the listing publishes at least one floor plan |
| `floorPlans` | Each plan: url (the image, or the SVG preview of an interactive scan), kind ('image' or 'interactive'), viewerUrl (interactive scans), caption (Redfin's), source |
| `floorPlanCount` | How many floor plans were found |
| `listingUrl` | The listing page, to open or revisit |
| `address, city, state, zip` | The property as the site resolved it |
| `propertyType, beds, baths, sqft, yearBuilt, status` | Core facts from the listing |
| `photos` | The listing's photo gallery ({url, width, height}), when includePhotos is on |
| `fromCache` | True when answered from our stored copy of a lookup in the last 30 days |

Sample:

```json
{
  "query": "6107 Felix Ave, Austin, TX 78741",
  "found": true,
  "hasFloorPlan": true,
  "floorPlanCount": 3,
  "floorPlans": [
    {
      "url": "https://visithome.ai/ii8Htw29Gt6HvCkktMozEC.svg",
      "kind": "interactive",
      "viewerUrl": "https://visithome.ai/ii8Htw29Gt6HvCkktMozEC",
      "source": "redfin"
    },
    {
      "url": "https://ssl.cdn-redfin.com/photo/92/bigphoto/662/3770662_35_0.jpg",
      "kind": "image",
      "caption": "Guest room layout",
      "source": "redfin"
    },
    {
      "url": "https://ssl.cdn-redfin.com/photo/92/bigphoto/662/3770662_34_0.jpg",
      "kind": "image",
      "caption": "Main residence layout",
      "source": "redfin"
    }
  ],
  "address": "6107 Felix Ave",
  "city": "Austin",
  "state": "TX",
  "zip": "78741",
  "source": "redfin",
  "fromCache": false
}
```

### Inputs

| Field | Required | Type | Default | Description |
|---|---|---|---|---|
| `addresses` | no | array | `["12307 Boneta Cv, Austin, TX 78729", "6107 Felix Ave, Austin, TX 78741"]` | US street addresses with city, state and ZIP, one per line, e.g. '12307 Boneta Cv, Austin, TX 78729'. One run checks the whole list on one warm browser. Most homes publish no floor plan (about 1 in 3 homes for sale do, almost no off-market homes), so listed homes are the best bet. |
| `address` | no | string | — | One address; kept for saved tasks and API callers that send one value. Combined with 'Addresses'. |
| `source` | no | string | `"auto"` | 'Redfin' checks Redfin, which carries most public floor plans (9 of 10 in our sample). 'Redfin + Realtor.com' also checks Realtor.com for plans only it tags; Realtor.com pages are opened through Apify's Web Fetch with YOUR Apify account, so Apify bills you for that separately (about $0.0015 a page). |
| `includePhotos` | no | boolean | `true` | Also return the listing's photo gallery (floor plans are always returned separately). |

### Pricing (Pay Per Event)

Two charges: a **per-search fee** (`address-checked`, *$0.003/search*) that covers the live, gated lookup, plus a **per-match fee** (`floor-plan-found`, *$0.02/match*). Example: a search returning **33 properties with a floor plan** ≈ **$0.96** ($0.003 search + 33 matches). A search with no matches is billed only the $0.003 search fee.

Example: 100 listed homes checked ($0.30) of which about a third have a floor plan (33 x $0.02 = $0.66). Realtor.com pages, when you choose them, are opened through Apify's Web Fetch on your account and billed by Apify separately (about $0.0015 a page). Apify platform usage is billed separately per your plan.

### Use cases

- Layout benchmarking: pull the floor plans of new townhomes and triple-deckers in a town to compare unit sizes and room layouts.
- Shortlist prep: get the floor plan of each home on a buyer's list before viewings.
- Database enrichment: add floor-plan links and a has-floor-plan flag to an address list.
- Renovation quotes: check whether a home has a published plan before a site visit.

### Why this actor

- Floor plans only, already separated from the photos, with Redfin's own caption on each plan image.
- Interactive CubiCasa 3D-scan plans come with a preview image and the viewer link.
- A clear hasFloorPlan flag on every row, so homes without a public plan are easy to filter out.
- Pay a small fee per address and per plan found; addresses no site can find are free.

### Limitations & updates

Only floor plans a listing publishes publicly; most homes, and almost all off-market homes, have none. US addresses only, with house number, city, state and ZIP. Links point to the listing sites' own files and can stop working if a listing is removed; no images are stored. Interactive scans open in CubiCasa's viewer. Lookups take a few seconds each; a stored copy from the last 30 days is returned instantly.

### FAQ

**Does every home have a floor plan?**

No. A floor plan is public only when the listing agent uploaded one. In a sample of 28 homes for sale on 2026-10-28, 10 had one (Redfin had 9 of those 10), and off-market homes rarely do. Rows say hasFloorPlan: false when there is none.

**Where do the floor plans come from?**

From the listing on Redfin: photos Redfin labels as floor plans, and interactive CubiCasa 3D-scan plans. With 'Redfin + Realtor.com' it also checks Realtor.com, which occasionally tags a plan Redfin does not show.

**Do you store or re-host the images?**

No. You get the links the listing site publishes. The plans and photos belong to the listing agents and photographers; use them accordingly. A link can stop working if the listing site removes it.

**How am I charged?**

$0.003 per address that resolves to a property, plus $0.02 per property with at least one floor plan. An address no site can find costs nothing. Realtor.com pages (optional) are billed by Apify to your account at about $0.0015 a page.

**What does fromCache mean?**

We keep a copy of each property looked up through our tools. If the same property was looked up in the last 30 days, the answer comes from that copy instantly; otherwise it is fetched live.

**Can I also get the full property record?**

Yes: Zillow & Redfin Property Data Scraper returns the full record (estimates, price and tax history, schools, agent) with the same floorPlans field.

### Which actor to choose

Related property tools in the same suite:

- **Zillow & Redfin Property Data Scraper** — You want the whole property record (estimates, price and tax history, schools, agent) along with the floor plans.
- **US Property Records Export & Owner Lookup** — You need the list of addresses first: every home of a type, built after a year, in a county or ZIP, from the assessor roll.

### Guides & use cases

Written up on **[scrapebench.dev](https://scrapebench.dev)** — the bench that runs and verifies this actor against the live source every night:

- **How-to:** [How to run Floor Plan Scraper: Home Floor Plans & Photos by Address](https://scrapebench.dev/guides/how-to-property-floor-plan-finder/)
- **Use case:** [Austin TX Home Floor Plans by Address](https://scrapebench.dev/use-cases/austin-floor-plans/)

More actors, coverage and nightly verification results: **[scrapebench.dev](https://scrapebench.dev)**

### Works with AI assistants (MCP)

Callable as an MCP tool, so Claude, Cursor, VS Code Copilot and other MCP clients can run it directly. Grab the config from the [MCP tab](https://apify.com/scrapebench/property-floor-plan-finder/api/mcp) on this page — Apify hosts the server and keeps that snippet current, and OAuth signs you in on first connect, so no API token goes in your config file.

Then just ask:

> "Find the floor plans for 6107 Felix Ave, Austin, TX 78741."

That home has three: an interactive CubiCasa scan and two layout images (test run, 2026-10-28). Runs started this way bill exactly like any other run.

### Data & lawful use

This actor collects publicly available information that Redfin and, when you choose it, Realtor.com; the plans and photos belong to the listing agents and photographers who publish them publishes for public
lookup — licence records, business listings and the contact details professionals list there.
Some of it identifies individuals (sole proprietors, licence holders, agents), so treat any
names, phone numbers and emails in your results as personal data.

When you run this actor, you decide what is collected and what it is used for, so you are the
controller of that data and we act only as your processor (Apify Standard Actor Contract).
You need a lawful basis for your use, must honour opt-out and deletion requests, and must
follow the marketing rules that apply to you (CAN-SPAM, TCPA, GDPR, CCPA and similar).
Don't use the output for unsolicited bulk messaging, for screening covered by the FCRA, or
for anything the source's own terms forbid.

Your results are stored in your own Apify account. We don't keep a copy of your results and
don't sell or share them.

### Disclaimer

This is an independent tool. It is not affiliated with, endorsed by or sponsored by
Redfin and, when you choose it, Realtor.com; the plans and photos belong to the listing agents and photographers who publish them. Names and marks are used only to describe the data source. Records are
provided as published by the source and may be out of date or incomplete. For anything
consequential (hiring, a permit, a legal decision), confirm the record with the issuing
agency. You are responsible for making sure your use complies with applicable law and the
source's terms.

### Need help?

Open an issue on this actor's **Issues** tab and we'll respond there. Bug reports, missing
fields and feature requests are all welcome. Guides and examples: [scrapebench.dev](https://scrapebench.dev).

If you are a person named in this data and want your record removed from our copy, email
apify-help@scrapebench.dev; the source agency remains the official record.

Your run may be used to improve our services. If something looks off, or you want this actor to fit your use better, please share your run data with us: [Apify Console → Settings → Security → Share run data with developers](https://console.apify.com/settings/security). It lets us see exactly what went wrong and keep improving the actor.

# Actor input Schema

## `addresses` (type: `array`):

US street addresses with city, state and ZIP, one per line, e.g. '12307 Boneta Cv, Austin, TX 78729'. One run checks the whole list on one warm browser. Most homes publish no floor plan (about 1 in 3 homes for sale do, almost no off-market homes), so listed homes are the best bet.

## `address` (type: `string`):

One address; kept for saved tasks and API callers that send one value. Combined with 'Addresses'.

## `source` (type: `string`):

'Redfin' checks Redfin, which carries most public floor plans (9 of 10 in our sample). 'Redfin + Realtor.com' also checks Realtor.com for plans only it tags; Realtor.com pages are opened through Apify's Web Fetch with YOUR Apify account, so Apify bills you for that separately (about $0.0015 a page).

## `includePhotos` (type: `boolean`):

Also return the listing's photo gallery (floor plans are always returned separately).

## Actor input object example

```json
{
  "addresses": [
    "12307 Boneta Cv, Austin, TX 78729",
    "6107 Felix Ave, Austin, TX 78741"
  ],
  "source": "auto",
  "includePhotos": true
}
```

# Actor output Schema

## `results` (type: `string`):

Each row is one address you asked for, with its floor plans when the listing publishes any.

# 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 = {
    "addresses": [
        "12307 Boneta Cv, Austin, TX 78729",
        "6107 Felix Ave, Austin, TX 78741"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapebench/property-floor-plan-finder").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 = { "addresses": [
        "12307 Boneta Cv, Austin, TX 78729",
        "6107 Felix Ave, Austin, TX 78741",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapebench/property-floor-plan-finder").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 '{
  "addresses": [
    "12307 Boneta Cv, Austin, TX 78729",
    "6107 Felix Ave, Austin, TX 78741"
  ]
}' |
apify call scrapebench/property-floor-plan-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapebench/property-floor-plan-finder"
        }
    }
}
```

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/Xquyzz4g1Ri01QeJq/builds/H1bDOfd0oXouabu9v/openapi.json