Redfin

Before configuring anything in Bubble, it is worth being clear about the landscape so you make the right data source choice for your use case. Redfin's internal API endpoints (visible in browser DevTools when browsing redfin.com) are explicitly prohibited for external use by Redfin's Terms of Service, Section 4: 'You agree not to copy, scrape, crawl, or otherwise access data from the Redfin Services through automated means.' Bubble applications that attempt to use these internal endpoints risk IP blocking (your Bubble app's server IPs get banned, breaking the integration for all users) and potential legal action. The data shapes also change without notice — an internal endpoint that works today may return a different structure or 404 tomorrow. Choose your legitimate data path based on your use case: **ATTOM Data Solutions** (recommended for most Bubble projects): self-serve at attomdata.com. Covers property detail, ownership, sale history, AVM estimates, neighborhood stats, school data, hazard risk. Per-call or subscription pricing. REST API with X-APIKey header. Best for investment research apps, agent tools, and property detail lookups. **RapidAPI Zillow providers**: available at rapidapi.com — search 'Zillow'. Multiple third-party providers offer Zillow-style listing data and Zestimate values. Free tiers with low call limits; paid plans for production. Data freshness and accuracy vary by provider — less consistent than ATTOM's licensed dataset. Best for listing search and home value estimates. **Redfin CSV exports** (redfin.com/news/data-center): free downloadable aggregate market data updated regularly — median sale prices, inventory, days on market by geography. Not an API; requires an external database step. Best for market trend charts where weekly or monthly refresh is sufficient. For this guide, the primary path is ATTOM Data. RapidAPI Zillow configuration is covered as an alternative.

Sign up at attomdata.com to create a developer account. After email verification, navigate to the API Keys section of the ATTOM dashboard and generate an API key. The key is available immediately — no approval wait. In your Bubble editor, go to Plugins → API Connector → Add another API. Name it 'ATTOM Property Data'. Configure: - Set the base URL: https://api.gateway.attomdata.com/propertyapi/v1.0.0 - Add a shared header: Key = X-APIKey, Value = [your ATTOM API key], check the 'Private' checkbox - Add a second shared header: Key = Accept, Value = application/json (static, no Private needed) Add your first call: 'Property Address Search'. Method: GET. URL path: /property/address. Add query parameters: - address1: [dynamic] — the street address (e.g., '123 Main St') - address2: [dynamic] — city and state (e.g., 'San Francisco, CA') - postalcode: [dynamic] — zip code For the Initialize call, use a real US address that you know exists. ATTOM's property endpoint works best with specific, complete addresses. A fully-formed address like '100 First St, San Francisco, CA 94105' will return a clean response for field detection. Click Initialize call. Bubble will hit ATTOM's live API and detect the response field structure. ATTOM's response nests the property object: property → summary (proptype, yearbuilt), property → building (beds, baths, size.bldgsize), property → address (line1, city, state, postal1). Bubble detects the nested paths automatically during initialization.

1// ATTOM Data API Connector configuration
2{
3  "method": "GET",
4  "url": "https://api.gateway.attomdata.com/propertyapi/v1.0.0/property/address",
5  "headers": {
6    "X-APIKey": "<your_attom_api_key_private>",
7    "Accept": "application/json"
8  },
9  "params": {
10    "address1": "<dynamic_street_address>",
11    "address2": "<dynamic_city_state>",
12    "postalcode": "<dynamic_zip_code>"
13  }
14}
15
16// Key ATTOM endpoints:
17// Property detail: /property/detail?attomid=<id>
18// Comparable sales: /sale/snapshot?postalcode=<zip>&radius=<miles>
19// AVM (value): /attomavm/detail?address1=<addr>&address2=<city_state>

ATTOM Data charges per API call. Searching the same address repeatedly (which happens naturally in a property research tool as users look up common properties multiple times) incurs redundant charges without any data benefit — property details do not change between searches. A PropertyCache data type with an expiry timestamp prevents redundant calls. Create a Bubble data type called PropertyCache with these fields: - attom_id (text) — ATTOM's internal property ID, used as cache key - address_line1 (text) - address_city (text) - address_state (text) - address_zip (text) - property_type (text) - beds (number) - baths (number) - building_sqft (number) - year_built (number) - last_sale_date (date) - last_sale_price (number) - estimated_value (number) - cache_expires_at (date) - search_address_hash (text) — a normalized version of the searched address for cache lookup In your property search workflow, add a cache check as the first step: 1. Normalize the input address: strip extra spaces, lowercase. Store as a text expression in the workflow. 2. Do a search for PropertyCache where search_address_hash = [normalized address] AND cache_expires_at > Current date/time. 3. If count > 0: use the cached PropertyCache record — skip the ATTOM API call entirely. 4. If count = 0: call ATTOM's Property Address Search API, then create a new PropertyCache record from the response with cache_expires_at = Current date/time + 1 hour. For comparable sales (less frequently searched, more expensive per call): set cache_expires_at = Current date/time + 6 hours. Sale history changes slowly — new comparable transactions are not added minute-to-minute. For AVM estimates (home value estimates): set cache_expires_at = Current date/time + 24 hours. AVM values are recalculated by ATTOM daily at most.

1// PropertyCache data type structure
2{
3  "attom_id": "12345678",
4  "address_line1": "123 main st",
5  "address_city": "san francisco",
6  "address_state": "ca",
7  "address_zip": "94105",
8  "property_type": "Single Family Residence",
9  "beds": 3,
10  "baths": 2,
11  "building_sqft": 1850,
12  "year_built": 1992,
13  "last_sale_date": "2023-06-15",
14  "last_sale_price": 1250000,
15  "estimated_value": 1380000,
16  "cache_expires_at": "2026-07-10T11:00:00Z",
17  "search_address_hash": "123 main st san francisco ca 94105"
18}
19
20// Cache check workflow logic:
21// Step 1: Do a search for PropertyCache
22//   search_address_hash = [normalized_input]
23//   cache_expires_at > Current date/time
24//   :count > 0 → use cached record
25//   :count = 0 → call ATTOM API

With the API Connector and cache layer configured, build the user-facing property search experience. Add a page in your Bubble app with: - A text input for street address (placeholder: '123 Main St') - A text input for city and state (placeholder: 'San Francisco, CA') - A text input for zip code (placeholder: '94105') - A 'Search' button - A results section (conditionally visible when results exist) The Search button workflow: 1. Normalize the address (lowercase, trim whitespace) and store in a custom state (search_hash). 2. Do a search for PropertyCache where search_address_hash = search_hash AND cache_expires_at > Current date/time. 3. If result count > 0: set a custom state 'current_property' to the first PropertyCache result. Show the results section. 4. If result count = 0: call ATTOM 'Property Address Search' with the input values. On success: create PropertyCache record from response fields (map ATTOM response paths to PropertyCache fields). Set current_property state. Show results. 5. If ATTOM call returns error (no property found, invalid address): show an alert 'Property not found — try a more specific address'. The results section elements: - Property address display (combined address_line1 + city + state + zip) - Property specifications: beds, baths, building_sqft formatted as 'X,XXX sq ft', year_built - Last sale: last_sale_date formatted as 'Month Year', last_sale_price formatted as '$X,XXX,XXX' - Estimated value: estimated_value formatted as '$X,XXX,XXX' - A 'View Comparables' button that triggers the comparable sales lookup for the current property's zip code For the comparable sales display: a separate Repeating Group (hidden until 'View Comparables' is clicked) showing comparable recent sales from ATTOM's /sale/snapshot endpoint filtered by the current property's zip code. Display sale date, sale price, beds, baths, sqft, and calculated price-per-sqft.

1// ATTOM comparable sales call
2{
3  "method": "GET",
4  "url": "https://api.gateway.attomdata.com/propertyapi/v1.0.0/sale/snapshot",
5  "headers": {
6    "X-APIKey": "<shared_private>",
7    "Accept": "application/json"
8  },
9  "params": {
10    "postalcode": "<dynamic_zip_code>",
11    "startsalesearchdate": "<dynamic_start_date>",
12    "endsalesearchdate": "<dynamic_end_date>",
13    "propertytype": "SFR",
14    "minsqft": "<dynamic_min_sqft>",
15    "maxsqft": "<dynamic_max_sqft>"
16  }
17}

If your use case requires active listing search (properties currently for sale, with listing price, listing agent, days on market) rather than just property detail and sale history, RapidAPI's Zillow providers offer this data. ATTOM focuses on historical and assessment data; RapidAPI Zillow providers include active MLS-sourced listing data. Go to rapidapi.com and search for 'Zillow' in the marketplace. Several third-party providers offer Zillow-style listing data. The most common is named 'Zillow-com1' or similar. Subscribe to a plan — free tiers are available but typically limited to around 10 requests/month, which is only sufficient for testing. A paid plan (verify current pricing at rapidapi.com) is needed for any real user traffic. After subscribing, copy your X-RapidAPI-Key from the RapidAPI dashboard. In Bubble's API Connector, add another API named 'RapidAPI Zillow'. Configure shared headers: - Key: X-RapidAPI-Key, Value: [your RapidAPI key], check Private - Key: X-RapidAPI-Host, Value: zillow-com1.p.rapidapi.com (static — this must match the provider you subscribed to), no Private needed Base URL: https://zillow-com1.p.rapidapi.com Add a 'Property Search' call: GET /propertyExtendedSearch with parameters: - location: [dynamic] — city/state or zip code string - price_min: [dynamic] - price_max: [dynamic] - beds_min: [dynamic] - property_type: [dynamic] — SingleFamily, MultiFamily, Townhome, Condo Initialize with a real location string (e.g., 'Seattle, WA'). RapidAPI Zillow responses nest listings under the 'props' array — each item has zpid (Zillow's property ID), address, price, beds, baths, livingArea, and imgSrc (listing photo URL). Note: RapidAPI providers are third-party operators, not Zillow directly. Data freshness, accuracy, and API availability depend on the provider's maintenance. For investment-grade applications where data reliability matters, ATTOM's licensed dataset is more consistent than any RapidAPI provider.

1// RapidAPI Zillow connector configuration
2{
3  "method": "GET",
4  "url": "https://zillow-com1.p.rapidapi.com/propertyExtendedSearch",
5  "headers": {
6    "X-RapidAPI-Key": "<your_rapidapi_key_private>",
7    "X-RapidAPI-Host": "zillow-com1.p.rapidapi.com"
8  },
9  "params": {
10    "location": "<dynamic_location>",
11    "price_min": "<dynamic_min_price>",
12    "price_max": "<dynamic_max_price>",
13    "beds_min": "<dynamic_min_beds>",
14    "property_type": "<dynamic_type>"
15  }
16}
17
18// RapidAPI Zillow property detail call
19{
20  "method": "GET",
21  "url": "https://zillow-com1.p.rapidapi.com/property",
22  "params": {
23    "zpid": "<dynamic_zillow_property_id>"
24  }
25}

For aggregate market statistics — median sale price by zip code, days on market trends, inventory counts, price-per-sqft over time — Redfin publishes free downloadable CSV files at redfin.com/news/data-center. These are not an API but they contain high-quality market trend data that Redfin itself uses for its Market Insights feature. Navigate to redfin.com/news/data-center. You will find downloadable CSV files for national, metro, county, zip code, and neighborhood level data. The zip code file contains columns: period_begin, period_end, region_type, region, zip_code, median_sale_price, homes_sold, pending_sales, new_listings, median_list_price, median_ppsf, months_of_supply, days_on_market. The workflow for using this data in Bubble: 1. Download the zip-code-level CSV from Redfin's data center. 2. Import it into an external PostgreSQL database (Supabase's free tier works perfectly for this). Create a table 'redfin_market_data' with columns matching the CSV headers. 3. Build a simple REST API endpoint on Supabase (or another backend) that accepts a zip_code parameter and returns filtered rows from the table. 4. In Bubble's API Connector, configure a new API pointing to your Supabase REST endpoint. 5. Build a market trends chart page in Bubble using Recharts or ApexCharts plugin, driven by the Supabase query results. Redfin updates these CSV files on a weekly or monthly basis. Set a reminder to re-download and re-import to your Supabase database on the same schedule — or set up a simple automation (n8n, Zapier, or a Supabase Edge Function) to fetch and import the updated CSV automatically. This data is freely available with no API key or rate limits — Redfin's terms of service for their public data exports are more permissive than for scraping their website, but verify current terms at redfin.com/about/legal.

1// Supabase REST query for Redfin market data
2// After importing Redfin CSV to Supabase 'redfin_market_data' table:
3
4// Bubble API Connector call:
5{
6  "method": "GET",
7  "url": "https://[your-project].supabase.co/rest/v1/redfin_market_data",
8  "headers": {
9    "apikey": "<your_supabase_anon_key_private>",
10    "Authorization": "Bearer <your_supabase_anon_key_private>"
11  },
12  "params": {
13    "zip_code": "eq.<dynamic_zip>",
14    "order": "period_begin.desc",
15    "limit": "24"
16  }
17}