Frequently Asked Questions
Everything you need to know about Real Estate API
Data Coverage & Quality
RealEstateAPI covers 159+ million properties nationwide, providing comprehensive coverage across all U.S. states with property ownership records, tax data, and listing information where available. This includes residential, commercial, and industrial properties with detailed information on ownership, valuation, and transaction history.
Property data is updated daily with new sales, ownership changes, and MLS listings. Public record updates vary by county (weekly to monthly), while MLS data refreshes in real-time from participating boards.
Skip tracing returns the owner's name, phone numbers, email addresses, current and previous addresses, and demographic details such as age. Coverage varies by owner, and most matches include more than one way to reach them.
The API primarily covers residential properties with comprehensive nationwide coverage. Commercial properties (office, retail, industrial, multi-family) are included where available, but data completeness varies significantly by county and property type. For commercial-focused applications, contact us to discuss coverage for your target markets. Or click below to view a full list of available property use codes
Yes. In the Property Search API you can filter for assumable loans using the top-level `assumable` boolean filter.
POST /v2/PropertySearch{
"zip": "22205",
"assumable": true
}- •The
assumablefilter is a top-level boolean parameter that finds properties with assumable mortgages - •Assumable mortgages can be transferred to a new buyer, often at favorable rates
- •Combine with other filters like
city,state, or mortgage balance ranges for targeted searches
Use the Property Search API with mortgage filter parameters to find properties by mortgage balance, private lender status, or free & clear status. Mortgage data like loan type and interest rate is available in the Property Detail response.
POST /v2/PropertySearch{
"city": "Arlington",
"state": "VA",
"mortgage_min": 200000,
"mortgage_max": 400000
}- •Use
mortgage_minandmortgage_maxto filter by open mortgage balance - •Use
private_lender: trueto find properties with private/hard money financing - •Use
free_clear: trueto find properties with no open mortgage - •Detailed loan info (loan type, interest rate, lender) available via Property Detail API
- •Mortgage data availability varies by county
Yes, foreclosure data includes filing dates, auction dates, case numbers, default amounts, trustee information, and auction addresses. Use foreclosure: true or pre_foreclosure: true in searches. We track properties through every stage of the foreclosure process from initial filing to auction completion.
AVM (Automated Valuation Model) uses statistical modeling and comparable sales for instant estimates. BPO (Broker Price Opinion) requires human analysis but provides more nuanced market insights. Our Lender Grade AVM provides confidence scores and valuation ranges to give more nuance than a single value figure can convey. AVMs are faster and more cost-effective, while BPOs offer deeper market analysis for complex properties.
AVM accuracy varies by market conditions, property type and how many recent comparable sales are available. Our Lender Grade AVM returns a confidence score and value range with every estimate, and its multi-model approach with recent sales data improves precision over single-model systems. Appraisals remain the standard where a lender or regulator requires one.
Property historical data ranges from state to state. But 10 to 20 years of transaction history is common. Some counties provide records dating back 30+ years, while others may have limited historical data due to digitization timelines.
Technical
Flat files can deliver timely data, but only if you manage a cadence of regular file deliveries and maintain pipelines to push those updates into your systems. An API eliminates that overhead by delivering always-current data in real time. Our API also supports complex filtering, advanced search functions such as radius queries, and automatic refreshes. Typical response times are under 100ms, which flat files cannot match. APIs also provide better error handling, authentication, and usage tracking capabilities.
As few as 1 API call using Property Detail with comps: true. For more control, use 2-3 separate calls for property details, comps, and valuation. A complete property analysis requires 1-3 API calls depending on your workflow:
Most efficient (1 call): Property Detail with `comps: true` → returns property data, owner info, AND comparable sales in a single response
Modular approach (2-3 calls):
- Property Detail → property characteristics and owner data
- Property Comps → comparable sales with customizable filters (radius, date range, exact match criteria)
- Property AVM (optional) → dedicated valuation with confidence scores
POST /v2/PropertyDetail
POST /v2/PropertyComps
POST /v2/PropertyAVM// Single call gets everything
const analysis = await fetch('https://api.realestateapi.com/v2/PropertyDetail', {
method: 'POST',
headers: {
'x-api-key': 'YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
address: "123 Main St, San Francisco, CA",
comps: true
})
});
// Response includes: property details, owner data, and comps- •Use
comps: truefor simple workflows; use dedicated Comps endpoint when you need advanced filtering (same_zip,year_built_boost, etc.) - •Property Detail includes current owner by default
- •Prior owner history available via
prior_owner: trueparameter
You can hit the API from the browser, but best practice is to call it from your backend so you don't expose your API key and so you can control rate limits and usage. Yes — technically the API is just HTTPS+JSON, so the browser can call it. But the recommended pattern is:
Your React app → hits your backend (or edge function)
Your backend → calls RealEstateAPI
Your backend → returns only the fields your UI needs
Why we recommend this:
- Keeps your API key/secret out of the browser
- Lets you enforce per-user limits (otherwise one user can blow through your credits)
- Lets you normalize / map the RealEstateAPI payload into your internal shape
- Lets you log and meter usage per tenant/customer
// Backend endpoint (Next.js API route example)
export async function POST(req) {
const { address } = await req.json();
const response = await fetch('https://api.realestateapi.com/v2/PropertySearch', {
method: 'POST',
headers: {
'x-api-key': process.env.REAPI_KEY, // ← Secured server-side
'Content-Type': 'application/json'
},
body: JSON.stringify({ address })
});
return response.json();
}Use the Address Verification API to validate and standardize addresses before searching. It returns a corrected, geocoded address that ensures accurate property matches.
Recommended workflow:
1. AutoComplete → guide user input with real-time suggestions (free for subscribers)
2. Address Verification → validate and standardize the selected address
3. Property Search/Detail → use the verified address for accurate results
Rate Limits:
- Address Verification: Max 100 addresses per request, 10 req/sec per API key
- AutoComplete: Unlimited free use for monthly subscribers
POST /v2/AutoComplete
POST /v2/AddressVerification// Step 1: AutoComplete guides user input (free)
const autocomplete = await fetch('https://api.realestateapi.com/v2/AutoComplete', {
method: 'POST',
headers: {
'x-api-key': 'YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
search: "123 main san francisco"
})
});
// Returns array of matching addresses with id, address, city, state, zip, lat/lng
// Step 2: Verify the selected address
const verification = await fetch('https://api.realestateapi.com/v2/AddressVerification', {
method: 'POST',
headers: {
'x-api-key': 'YOUR_API_KEY',
'Content-Type': 'application/json'
},
body: JSON.stringify({
addresses: [{
key: "1",
street: "123 Main St",
city: "San Francisco",
state: "CA",
zip: "94102"
}]
})
});
// Returns: { data: [{ match: true, confidence: 0.95, id: "12345", address: {...} }] }
// Step 3: Use verified property ID for detail lookup
const verifiedData = await verification.json();
if (verifiedData.data[0].match) {
const property = await fetch('https://api.realestateapi.com/v2/PropertyDetail', {
method: 'POST',
headers: { 'x-api-key': 'YOUR_API_KEY', 'Content-Type': 'application/json' },
body: JSON.stringify({ id: verifiedData.data[0].id })
});
}- •Confidence score > 0.85 indicates a verified match
- •Address Verification corrects misspellings, abbreviations, and missing ZIP codes
- •Returns geocoded coordinates (latitude/longitude) for mapping
- •AutoComplete supports search types: address, city/state, county, ZIP, APN
- •Use the returned property ID for fastest Property Detail lookups
Rate limits vary by endpoint and are measured in credits per 24-hour window. Property Search allows 1,000,000 credits per day (excluding 'count' or 'ids_only' calls), while Property Detail/Bulk endpoints allow 500,000 credits per day. Address Verification has specific limits of 10 requests/second by API key and 3 requests/second per user ID, with up to 100 addresses per request. Contact support for higher limits if needed.
Yes, the Property Detail Bulk endpoint processes up to 1,000 property IDs in a single request. Use ids_only: true in Property Search to retrieve IDs, then batch them through the bulk endpoint.
POST /v2/PropertyDetailBulk// Step 1: Get property IDs from search
const search = await fetch('https://api.realestateapi.com/v2/PropertySearch', {
method: 'POST',
headers: { 'x-api-key': 'YOUR_API_KEY', 'Content-Type': 'application/json' },
body: JSON.stringify({
city: "Austin",
state: "TX",
ids_only: true,
size: 1000
})
});
const { data } = await search.json();
const propertyIds = data.map(p => p.id);
// Step 2: Get full details in bulk
const bulk = await fetch('https://api.realestateapi.com/v2/PropertyDetailBulk', {
method: 'POST',
headers: { 'x-api-key': 'YOUR_API_KEY', 'Content-Type': 'application/json' },
body: JSON.stringify(propertyIds) // Array of IDs directly
});- •Returns up to 10,000 IDs per Property Search query
- •Bulk endpoint accepts array of property IDs directly (not wrapped in object)
- •Bulk requests reduce API calls by 99% vs individual property lookups
- •Synchronous response with array of property objects
- •Failed IDs return null in their array position
You can access our Postman collections here: https://www.postman.com/realestateapis. We also provide code samples in Python, Node.js, PHP, and other popular languages in our developer documentation.
Billing & Plans
We have three plan tiers: Starter ($599/mo), Growth ($1200/mo) and Pro ($2500/mo). As you ascend in the plans you get access to more endpoints--and more property records are included. Each plan includes different credit allocations and feature access to match your business needs.
Yes. Upgrades take effect immediately, with prorated billing for the rest of your current cycle. To move to a smaller plan, contact support and we'll schedule the change with you. Monitor usage in the dashboard to pick the right plan.
Credit cards (Visa, MasterCard, American Express, Discover) and ACH bank transfer. Detailed invoicing and usage tracking available in our user console. Enterprise accounts can also arrange wire transfer payments.
You get $200 in API credits to use over 14 days, with full API access to test every endpoint. No credit card required.
Each unit of overage is billed at the same unit price for your subscription plan.
Yes, we now offer pay as you go plans. They are month to month access. For a small premium you can have maximum flexibility. Annual subscriptions offer the most favorable pricing.
Yes, Enterprise accounts get access to volume discounts as well as custom development and priority support. If you're interested in our highest tier of service, contact sales by clicking below.
Advanced Features & Workflows
Yes. Use Property Search with geographic filters (city, county, ZIP, radius, or polygon) to retrieve properties, then aggregate the data for neighborhood or market-level analytics. The Property Search API returns property-level data that you can aggregate into neighborhood or market analytics. Use geographic filters to define your area, then calculate metrics from the results.
POST /v2/PropertySearch{
"city": "Austin",
"state": "TX",
"property_type": "SFR",
"last_sale_date_min": "2024-01-01",
"size": 10000,
"ids_only": true
}- •Median/average property values, price per sqft, equity levels
- •Vacancy rates, owner occupancy percentages
- •Days on market, sales velocity
- •Property age distribution, characteristics mix
- •Mortgage types, foreclosure rates
Yes, the API supports integration with popular CRM and marketing platforms including Salesforce, Hubspot and GoHighLevel.
Use Property Detail for property characteristics and ownership, Property AVM for valuation, and Property Comps for market validation. Combine this data with your underwriting criteria to automate qualification workflows. The API provides key data points for underwriting and loan qualification workflows. Retrieve property valuation, ownership, lien information, and market comparables, then apply your underwriting criteria programmatically.
Typical underwriting workflow:
1. Address Verification → validate and standardize the subject property address
2. Property Detail → get property characteristics, tax assessment, existing mortgages/liens, owner information
3. Property AVM → automated valuation with confidence scores and value ranges
4. Property Comps → validate AVM with recent comparable sales
POST /v2/AddressVerification
POST /v2/PropertyDetail
POST /v2/PropertyAVM
POST /v2/PropertyCompsconst headers = { 'x-api-key': 'YOUR_API_KEY', 'Content-Type': 'application/json' };
const address = "123 Main St, San Francisco, CA";
// 1. Get property details and existing liens
const property = await fetch('https://api.realestateapi.com/v2/PropertyDetail', {
method: 'POST',
headers,
body: JSON.stringify({ address })
}).then(r => r.json());
// 2. Get AVM valuation
const valuation = await fetch('https://api.realestateapi.com/v2/PropertyAVM', {
method: 'POST',
headers,
body: JSON.stringify({ address })
}).then(r => r.json());
// 3. Apply your underwriting rules
const loanAmount = 250000;
const ltv = (loanAmount / valuation.data.avm) * 100;
const qualified = ltv <= 80 && property.data.propertyType === 'SFR';Our API offers nearly 100 different search parameters. They can be combined into any permutation to produce compound queries. Advanced filtering includes things like geographic boundaries, property characteristics, and market conditions.
Still need help?
Can't find what you're looking for? Our support team is here to help.
Contact Support