# How to Integrate Retool with Realtor.com

- Tool: Retool
- Difficulty: Intermediate
- Time required: 25 minutes
- Last updated: April 2026

## TL;DR

Connect Retool to Realtor.com property data by subscribing to the Realtor.com Real Estate API on the RapidAPI marketplace, then configuring a REST API Resource with the X-RapidAPI-Key and X-RapidAPI-Host headers. Query property listings, agent data, and market statistics by location, price range, and property type. Build real estate search dashboards and listing management panels for agents and property managers using Retool Tables, Maps, and Charts.

## Why connect Retool to Realtor.com?

Real estate teams — brokerages, property managers, investment analysts — need to work with listing data alongside their own internal records: client preferences, transaction histories, commission tracking, and portfolio data. Realtor.com's native website interface is designed for public consumers, not for the operational workflows of real estate professionals. Connecting Retool to Realtor.com property data enables building custom internal tools that combine listing information with your team's existing data in a single panel.

The most valuable use case is a listing research dashboard for buyer's agents. Rather than switching between Realtor.com, a CRM, and a spreadsheet, an agent can open a Retool panel that searches Realtor.com listings by zip code and price range, displays results alongside client preference profiles from the internal database, and shows flags when a listing matches a client's saved criteria. Investment analysts can build comparable sales dashboards that pull recent Realtor.com sold listings for a target neighborhood and display them alongside their own deal metrics.

Access to Realtor.com data is provided through the RapidAPI marketplace, which hosts multiple Realtor.com API products with varying data depth and freshness. The API provides property search by location, price, property type, and bedroom count; property detail pages with full listing information; agent and office directories; and market statistics by zip code. Response payloads use deeply nested JSON structures, so JavaScript transformers are essential for reshaping the data into flat arrays that Retool Tables can display efficiently.

## Before you start

- A RapidAPI account (rapidapi.com) with a subscription to the Realtor.com Real Estate API (search for 'Realtor' on RapidAPI marketplace)
- Your RapidAPI API key (found in the code examples panel of any subscribed API on RapidAPI)
- The X-RapidAPI-Host value for the Realtor.com API (typically realtor.p.rapidapi.com — confirm in the API's code examples)
- Familiarity with Retool's query editor and REST API Resources
- A Retool account with Resource creation permissions

## Step-by-step guide

### 1. Subscribe to the Realtor.com API on RapidAPI

Navigate to rapidapi.com and search for 'Realtor' in the marketplace search bar. You will find several results — look for the official Realtor.com Real Estate API or similar highly-rated listing APIs (there are multiple providers offering Realtor.com data). Compare pricing plans and data freshness claims. Select the API that fits your use case — the free Basic tier on most Realtor.com API listings provides several hundred monthly calls, sufficient for testing and low-volume internal tools. Click Subscribe to Plan on your chosen plan and confirm the subscription. After subscribing, click on the API's Endpoints tab to browse available endpoints: you will typically see endpoints for property search (for-sale listings), sold listings, property detail by property ID or MLS number, agent search, and market statistics. Click on the property search endpoint and find the Code Snippets panel on the right side of the page. Select the Shell or JavaScript tab. You will see two critical values: X-RapidAPI-Key (your account-wide API key) and X-RapidAPI-Host (the host for this specific API, such as realtor.p.rapidapi.com). Copy both values and also note the full request URL shown in the curl example — the base URL is the host with https://, and the path after the host is the endpoint path you will use in Retool queries. Test the endpoint directly in the RapidAPI playground by entering sample values and clicking the Test Endpoint button to see the live response structure.

**Expected result:** You have an active subscription to a Realtor.com API on RapidAPI and have copied your X-RapidAPI-Key and X-RapidAPI-Host values. You can see sample response data from the API playground.

### 2. Configure the REST API Resource in Retool

In Retool, click the Resources tab in the left sidebar, then click Add Resource. Select REST API from the resource type list. In the Name field, enter Realtor.com API (or a more specific name like RapidAPI - Realtor.com to make it clear this goes through RapidAPI). In the Base URL field, enter https://realtor.p.rapidapi.com — replace with the actual host value if your chosen API uses a different host. In the Headers section, you need to add two headers that RapidAPI requires for every request. Click Add Header for the first header: set Name to X-RapidAPI-Key and Value to the API key you copied from RapidAPI. For security, store the API key as a Retool configuration variable first: go to Settings → Configuration Variables in the left sidebar, click Add variable, name it RAPIDAPI_KEY, paste the key as the value, and check Mark as secret. Then return to the Resource and set the X-RapidAPI-Key value to {{ config.RAPIDAPI_KEY }}. Click Add Header for the second header: set Name to X-RapidAPI-Host and Value to realtor.p.rapidapi.com (the plain domain, without https://). This host header is critical — it tells the RapidAPI gateway which API to route your request to. Do not add a default Authorization header; RapidAPI uses custom headers rather than standard Bearer auth. Click Save to save the Resource. You are now ready to create queries that target this Resource.

**Expected result:** The Realtor.com REST API Resource is saved in Retool with the correct base URL and both RapidAPI headers. The Resource appears in your Resources list and is ready for query creation.

### 3. Create a property search query with dynamic filters

In your Retool app, open the Code panel and click Create new query. Select the Realtor.com API Resource you created. Set Method to GET. In the Path field, enter the endpoint path for property search — this varies by API but is typically /properties/v3/list or /for-sale. Check your specific API's endpoint documentation on RapidAPI for the exact path. In the URL Parameters section, add the parameters for the search. Most Realtor.com APIs require at minimum a location parameter — typically city and state_code, or a postal_code. Add the following parameters and set their values to reference Retool components: postal_code → {{ zipInput.value }}, price_min → {{ priceMinInput.value || 0 }}, price_max → {{ priceMaxInput.value || 5000000 }}, beds_min → {{ bedsSelect.value || 1 }}, property_type → {{ propertyTypeSelect.value || 'single_family' }}, limit → 50, offset → {{ (pagination.page - 1) * 50 }}. You will add the input components (zipInput, priceMinInput, etc.) to the canvas in the next step. Set Run this query on page load to off — it should only run when the user clicks a Search button. Add the query. The Realtor.com API response is deeply nested; the actual listings array is typically inside a path like data.home_search.results or data.properties — run the query with a test zip code to check the exact path, then build your transformer.

```
// JavaScript transformer for Realtor.com property search results
// Adjust property paths based on your specific API version's response structure
const raw = data;

// Common response paths — try each if results is empty:
// data.data?.home_search?.results
// data.data?.properties
// data.properties
// data.results
const listings = raw?.data?.home_search?.results
  || raw?.data?.properties
  || raw?.properties
  || raw?.results
  || [];

return listings.map(item => {
  const desc = item.description || {};
  const loc = item.location?.address || {};
  const price = item.list_price || item.price || 0;

  return {
    property_id: item.property_id || '',
    address: loc.line || item.address?.line || 'N/A',
    city: loc.city || item.address?.city || '',
    state: loc.state_code || item.address?.state_code || '',
    zip: loc.postal_code || item.address?.postal_code || '',
    price: price ? `$${Number(price).toLocaleString()}` : 'N/A',
    price_raw: price,
    beds: desc.beds || item.beds || 0,
    baths: desc.baths || item.baths || 0,
    sqft: desc.sqft ? Number(desc.sqft).toLocaleString() : 'N/A',
    price_per_sqft: (price && desc.sqft)
      ? `$${Math.round(price / desc.sqft).toLocaleString()}`
      : 'N/A',
    status: item.status || 'for_sale',
    days_on_market: item.list_date
      ? Math.floor((Date.now() - new Date(item.list_date)) / 86400000)
      : 'N/A',
    listing_url: item.href || `https://www.realtor.com/realestateandhomes-detail/${item.property_id}`,
    thumbnail: item.primary_photo?.href || ''
  };
});
```

**Expected result:** The property search query runs and returns a flat array of listing objects with address, price, bedroom count, and other key fields. The data is ready to bind to a Retool Table component.

### 4. Build the listing search UI with filters and detail view

With the query working, build the search UI. At the top of the canvas, add a row of filter components inside a Container. Add a Text Input named zipInput with placeholder 'Enter zip code'. Add two Number Input components named priceMinInput (labeled 'Min Price') and priceMaxInput (labeled 'Max Price'). Add a Select component named bedsSelect with options for 1, 2, 3, 4, 5+ bedrooms. Add a Select component named propertyTypeSelect with options for Single Family, Condo, Townhouse, Multi-Family. Add a Button labeled Search Properties with an event handler set to Trigger query → propertySearchQuery. Below the filter row, drag a Table component onto the canvas. Set its Data source to {{ propertySearchQuery.data }}. Configure columns: Address (text), Price (the formatted price string), Beds (number), Baths (number), Sqft (number), Days on Market (number), Status (tag with green for active, yellow for contingent). Enable sorting on the Price and Days on Market columns. Add a Row click event handler on the Table set to Trigger query → propertyDetailQuery (which fetches full property details for the selected row's property_id). On the right side of the canvas, add a Container or Drawer for the property detail view. Bind it to show when {{ propertyTable.selectedRow !== null }}. Inside, add text fields for full address, description, agent information, and a Button labeled View on Realtor.com that opens {{ propertyTable.selectedRow.listing_url }} in a new tab. Add a Stat component above the Table showing the count of results: {{ propertySearchQuery.data.length }} listings found.

**Expected result:** A complete listing search UI is visible with filter inputs, a Search button, a Table displaying property results, and a detail panel that appears when a listing is selected. The Search button correctly triggers the API query and populates the Table.

### 5. Add market statistics and export capabilities

Enhance the dashboard by adding neighborhood market context alongside the listings. Check if your RapidAPI subscription includes a market statistics or neighborhood data endpoint — many Realtor.com API providers include endpoints for median list price, days on market average, and price per sqft trends by zip code. Create a second query targeting a market stats endpoint using the same zipInput.value. This query can be set to Run automatically when zipInput.value changes (with a debounce of 500ms to avoid firing on every keystroke) to update the market summary whenever the zip code changes. Add Stat components at the top of the dashboard showing: Median Price, Average Days on Market, Number of Active Listings — all sourced from the market stats query. For the comparison functionality, add a second Table below the main listings Table showing recently sold properties — create a third query targeting a sold listings endpoint with the same zip code filter. Add a Button labeled Export to CSV that triggers Retool's built-in CSV export on the listings table (Table component → Actions → Download CSV). For teams that need to combine this listing data with internal client preference databases or CRM records, configure a parallel PostgreSQL query that fetches active buyer profiles and their saved search criteria, then use a JavaScript transformer to flag listings that match any client's criteria with a highlight color in the Table's conditional formatting.

```
// JavaScript transformer for market statistics from the API
// Normalize market stats data for Stat components
const stats = data?.data?.market_statistics
  || data?.statistics
  || data?.market_data
  || {};

return {
  median_price: stats.median_list_price
    ? `$${Number(stats.median_list_price).toLocaleString()}`
    : 'N/A',
  median_dom: stats.median_days_on_market
    ? `${stats.median_days_on_market} days`
    : 'N/A',
  active_count: stats.active_listing_count
    || stats.total_listings
    || 'N/A',
  median_ppsf: stats.median_price_per_sqft
    ? `$${Math.round(stats.median_price_per_sqft)}/sqft`
    : 'N/A',
  month_supply: stats.months_supply
    ? `${stats.months_supply} months`
    : 'N/A'
};
```

**Expected result:** The dashboard displays market statistics Stat components at the top showing median price, average days on market, and active listing count for the searched zip code. A sold listings Table below provides comp data, and an Export CSV button allows data export.

## Best practices

- Store your RapidAPI key in a Retool configuration variable marked as secret (Settings → Configuration Variables) rather than hardcoding it in the Resource — this prevents exposure and enables key rotation without editing the Resource.
- Add a Search button to trigger property search queries rather than running them automatically on every input change — property search APIs on RapidAPI have monthly call limits, and automatic triggers can exhaust them quickly.
- Enable Retool query caching (5-10 minutes) on market statistics queries since neighborhood data does not change in real-time and caching significantly reduces API calls for shared dashboards.
- Build a fallback transformer that handles different response schemas — different RapidAPI Realtor.com providers return data in different structures, and a flexible transformer with multiple fallback paths (||) is more resilient than one that assumes a fixed schema.
- Include a direct link to each listing's Realtor.com page in the Table so agents can open the full listing with photos and history in a new tab without leaving Retool.
- Monitor your RapidAPI subscription quota in the Developer Dashboard and set up billing alerts before exhausting the free tier — plan upgrades take immediate effect, avoiding data gaps.
- Use Retool's Table conditional formatting to highlight listings that match internal client criteria (pulling from a CRM database) rather than manually comparing — this automation is the primary value of combining Realtor.com data with internal systems.

## Use cases

### Property listing search panel for buyer's agents

Build a Retool listing search tool where agents enter a city, zip code, or address and apply filters for price range, bedrooms, bathrooms, and property type. The panel queries the Realtor.com API via RapidAPI and displays matching listings in a Table with key fields: address, list price, beds, baths, square footage, days on market, and listing status. Selecting a row shows a full detail panel with the property description, photos, and agent contact information.

Prompt example:

```
Build a Retool property search panel that accepts a zip code text input and price range slider controls. Query the Realtor.com API via RapidAPI for for-sale listings with those filters. Show results in a Table with address, price, beds, baths, sqft, and days on market columns. When a row is selected, display a detail Container with the listing description, agent name, and a link to the Realtor.com listing page.
```

### Comparable sales analysis dashboard for real estate investors

Create a Retool panel for analyzing comparable sold properties in a target neighborhood. Query the Realtor.com API for recently sold listings within a radius of a target address, display them in a Table sorted by sold date, and use a Chart component to visualize price per square foot distribution. Layer in internal deal data from a PostgreSQL database to compare potential acquisitions against actual comps.

Prompt example:

```
Build a Retool comparable sales dashboard where I enter a target address and select a radius in miles. Query the Realtor.com API for sold properties in that area within the last 6 months. Show results in a Table sorted by sold_date descending with columns for address, sold price, price per sqft, beds, baths, and days on market. Add a histogram Chart showing the distribution of prices per sqft across all results.
```

### Agent directory and performance tracker

Build a Retool panel for tracking real estate agents in a target market area. Query the Realtor.com API for agent listings by zip code or city, display agent profiles with listing counts, review scores, and contact information in a Table. Cross-reference results with internal referral tracking data from a CRM database to identify agents who have closed deals with your team before.

Prompt example:

```
Build a Retool agent directory panel that searches the Realtor.com API for agents by zip code. Show results in a Table with agent name, brokerage, listing count, review score, and phone number. Add a Select dropdown for filtering by specialty (buyer's agent, seller's agent, etc.). Show a detail Container with the agent's recent listings when a row is selected.
```

## Troubleshooting

### Query returns 403 Forbidden with message 'You are not subscribed to this API'

Cause: The RapidAPI subscription to the Realtor.com API is not active, or the X-RapidAPI-Key header in the Retool Resource does not match the API key for the account that has the subscription.

Solution: Log in to rapidapi.com and go to My Apps → Application to confirm your API key. Navigate to your subscriptions in the RapidAPI Dashboard and verify the Realtor.com API shows as an active subscription. Copy the API key shown in the code example panel on the API page and update the RAPIDAPI_KEY configuration variable in Retool Settings → Configuration Variables.

### Transformer returns an empty array even though the raw API response contains listings

Cause: The response structure from the specific RapidAPI Realtor.com provider does not match the field paths in the transformer — different API providers on RapidAPI use different response schemas.

Solution: Temporarily set the transformer to return data; and examine the full response structure in Retool's query result panel. Look for where the listings array actually lives in the response (expand all nested objects). Update the transformer's top-level accessor from data?.data?.home_search?.results to the correct path you find. Common alternatives include data?.results, data?.data?.listing, or data?.properties.

```
// Debug: temporarily return raw data to inspect structure
return data;
// Check the query result panel, then update the correct path
```

### Query returns 429 Too Many Requests after a short period of use

Cause: The free tier RapidAPI subscription has been exhausted for the month, or the query is running too frequently due to automatic re-runs on every component change.

Solution: Check your RapidAPI Dashboard to see the remaining quota for the month. Enable Retool query caching (query → Advanced → Cache → 5 minutes minimum) to reduce API calls. Change the query from automatic to manual trigger (run on Search button click only). If the quota is genuinely too low for your use case, upgrade to a paid RapidAPI plan for the Realtor.com API.

### Property details query works but returns missing fields like description or photo URLs

Cause: The property search endpoint returns summary data while the full property details require a separate detail endpoint call using the property_id from the search results.

Solution: Create a second query targeting the property detail endpoint (typically /properties/v3/detail or /property-detail) with the property_id from the selected row as a path parameter or URL parameter. Set this query to trigger when the table row is selected using an event handler on the table's Row click event.

## Frequently asked questions

### Does Realtor.com have an official API for developers?

Realtor.com does not currently offer a public self-serve developer API. The primary way for developers to access Realtor.com listing data is through third-party API providers on the RapidAPI marketplace, which aggregate and serve Realtor.com data under their own API products. Enterprise data partnerships with News Corp (Realtor.com's parent company) are available for large-scale commercial use cases.

### How current is the Realtor.com data available through RapidAPI?

Data freshness varies by API provider on the RapidAPI marketplace. Most providers update their Realtor.com data feeds every 1-24 hours, which is sufficient for research and analysis use cases but may lag behind real-time listing changes. Check the specific API provider's documentation on RapidAPI for their stated data refresh frequency before subscribing.

### Can I search for sold properties as well as active listings?

Yes, most Realtor.com API providers on RapidAPI include separate endpoints for recently sold properties in addition to active for-sale listings. Look for endpoints labeled sold, recently-sold, or sold-homes in the API's endpoint list on RapidAPI. Create a separate Retool query targeting the sold listings endpoint using the same Resource configuration, and display the results in a second Table for comparable sales analysis.

### Can I access Realtor.com data for commercial properties through RapidAPI?

Realtor.com primarily focuses on residential real estate, and the RapidAPI data coverage reflects this — you will find comprehensive single-family, condo, townhouse, and multi-family residential data. For commercial real estate (office, retail, industrial), CoStar is the dominant data source and provides more comprehensive commercial property data through its enterprise API program.

### How many API calls does a typical real estate search Retool dashboard use per day?

A typical Retool listing search dashboard with one search per minute across a small team generates approximately 100-500 API calls per day. With Retool query caching enabled (5-minute cache), each unique zip code search is only called once per cache window, significantly reducing total calls. Most RapidAPI free tiers for Realtor.com APIs allow 500-1000 calls per month — a paid plan is advisable for any team dashboard with more than one or two users.

---

Source: https://www.rapidevelopers.com/retool-integrations/realtor-com
© RapidDev — https://www.rapidevelopers.com/retool-integrations/realtor-com
